Test Failure: Transforms/LoopIdiom/X86/arithmetic-right-shift-until-zero.ll

Test source: git

Comments: LLVM PR51669

Log:

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

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @p1(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nuw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p1(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @p2(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p2(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n3(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nuw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n3(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nuw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n4(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n4(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n5(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n5(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @p6(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %val.shifted = ashr i8 %val, %iv
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %iv, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %iv.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p6(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i8 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %iv, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %iv.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i7 @p7(i7 %val, i7 %start, i7 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i7 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i7 %iv, %extraoffset
  %val.shifted = ashr i7 %val, %nbits
  %val.shifted.iszero = icmp eq i7 %val.shifted, 0
  %iv.next = add i7 %iv, 1
  call void @escape_inner.i7(i7 %iv, i7 %nbits, i7 %val.shifted, i1 %val.shifted.iszero, i7 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i7 [ %iv, %loop ]
  %nbits.res = phi i7 [ %nbits, %loop ]
  %val.shifted.res = phi i7 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i7 [ %iv.next, %loop ]
  call void @escape_outer.i7(i7 %iv.res, i7 %nbits.res, i7 %val.shifted.res, i1 %val.shifted.iszero.res, i7 %iv.next.res)
  ret i7 %iv.res
}
=>
define i7 @p7(i7 %val, i7 %start, i7 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i7 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i7 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i7 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i7 %val.shifted, 0
  assume i1 1
  %iv.next = add i7 %iv, 1
  assume i1 1
  call void @escape_inner.i7(i7 %iv, i7 %nbits, i7 %val.shifted, i1 %val.shifted.iszero, i7 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i7 [ %iv, %loop ]
  %nbits.res = phi i7 [ %nbits, %loop ]
  %val.shifted.res = phi i7 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i7 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i7(i7 %iv.res, i7 %nbits.res, i7 %val.shifted.res, i1 %val.shifted.iszero.res, i7 %iv.next.res)
  ret i7 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n8(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 2
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n8(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 2
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @t9(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @t9(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n10(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n10(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n11(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n11(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n12(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 1
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n12(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n13(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop.end ]
  br label %loop.end

%loop.end:
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop.end ]
  %nbits.res = phi i8 [ %nbits, %loop.end ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop.end ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop.end ]
  %iv.next.res = phi i8 [ %iv.next, %loop.end ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n13(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop.end ]
  assume i1 1
  br label %loop.end

%loop.end:
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop.end ]
  %nbits.res = phi i8 [ %nbits, %loop.end ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop.end ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop.end ]
  %iv.next.res = phi i8 [ %iv.next, %loop.end ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n14(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp ult i8 %val.shifted, 1
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n14(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp ult i8 %val.shifted, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @t15(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %extraoffset, %iv
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @t15(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %extraoffset, %iv
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n16(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nsw i8 %extraoffset, %iv
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n16(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i8 %extraoffset, %iv
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n17(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %extraoffset = call i8 @gen.i8()
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n17(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %extraoffset = call i8 @gen.i8()
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n18(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %extraoffset = call i8 @gen.i8()
  %nbits = sub nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n18(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %extraoffset = call i8 @gen.i8()
  assume i1 1
  %nbits = sub nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n19(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop.preheader

%loop.preheader:
  %notiv = phi i8 [ 0, %entry ]
  br label %loop

%loop:
  %iv = phi i8 [ %start, %loop.preheader ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %notiv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n19(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop.preheader

%loop.preheader:
  %notiv = phi i8 [ 0, %entry ]
  assume i1 1
  br label %loop

%loop:
  %iv = phi i8 [ %start, %loop.preheader ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %notiv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n20(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = add i8 0, 0
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n20(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = add i8 0, 0
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n21(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 0, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n21(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 0, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n22(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %not.iv.next = add i8 %iv, 1
  %iv.next = add i8 %iv, 1
  %also.iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n22(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %not.iv.next = add i8 %iv, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  %also.iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @n23(i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val = call i8 @gen.i8()
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n23(i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val = call i8 @gen.i8()
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i1 @t24_nooffset_i1(i1 %val, i1 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  %val.shifted = ashr i1 %val, %iv
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  %iv.next = add i1 %iv, 1
  call void @escape_inner.i1(i1 %iv, i1 %iv, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  call void @escape_outer.i1(i1 %iv.res, i1 %iv.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
=>
define i1 @t24_nooffset_i1(i1 %val, i1 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i1 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %iv, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %iv.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i2 @t25_nooffset_i2(i2 %val, i2 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  %val.shifted = ashr i2 %val, %iv
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  %iv.next = add i2 %iv, 1
  call void @escape_inner.i2(i2 %iv, i2 %iv, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  call void @escape_outer.i2(i2 %iv.res, i2 %iv.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
=>
define i2 @t25_nooffset_i2(i2 %val, i2 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i2 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %iv, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %iv.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i3 @t26_nooffset_i3(i3 %val, i3 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  %val.shifted = ashr i3 %val, %iv
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  %iv.next = add i3 %iv, 1
  call void @escape_inner.i3(i3 %iv, i3 %iv, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  call void @escape_outer.i3(i3 %iv.res, i3 %iv.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
=>
define i3 @t26_nooffset_i3(i3 %val, i3 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i3 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %iv, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %iv.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i1 @t27_addnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i1 %iv, %extraoffset
  %val.shifted = ashr i1 %val, %nbits
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  %iv.next = add i1 %iv, 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
=>
define i1 @t27_addnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i2 @t28_addnsw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i2 %iv, %extraoffset
  %val.shifted = ashr i2 %val, %nbits
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  %iv.next = add i2 %iv, 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
=>
define i2 @t28_addnsw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i3 @t29_addnsw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i3 %iv, %extraoffset
  %val.shifted = ashr i3 %val, %nbits
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  %iv.next = add i3 %iv, 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
=>
define i3 @t29_addnsw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i1 @t30_addnuw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nuw i1 %iv, %extraoffset
  %val.shifted = ashr i1 %val, %nbits
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  %iv.next = add i1 %iv, 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
=>
define i1 @t30_addnuw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i2 @t31_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nuw i2 %iv, %extraoffset
  %val.shifted = ashr i2 %val, %nbits
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  %iv.next = add i2 %iv, 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
=>
define i2 @t31_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i3 @t32_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nuw i3 %iv, %extraoffset
  %val.shifted = ashr i3 %val, %nbits
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  %iv.next = add i3 %iv, 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
=>
define i3 @t32_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i1 @t33_subnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nsw i1 %iv, %extraoffset
  %val.shifted = ashr i1 %val, %nbits
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  %iv.next = add i1 %iv, 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
=>
define i1 @t33_subnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i2 @t34_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nsw i2 %iv, %extraoffset
  %val.shifted = ashr i2 %val, %nbits
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  %iv.next = add i2 %iv, 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
=>
define i2 @t34_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i3 @t35_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = sub nsw i3 %iv, %extraoffset
  %val.shifted = ashr i3 %val, %nbits
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  %iv.next = add i3 %iv, 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
=>
define i3 @t35_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define i8 @n36(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @n36(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @p37(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p37(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!


----------------------------------------
define i8 @p38(i8 %val.crude, i8 %start, i8 %extraoffset) {
%entry:
  %val = and i8 %val.crude, 127
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  %nbits = add nsw i8 %iv, %extraoffset
  %val.shifted = ashr i8 %val, %nbits
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  %iv.next = add i8 %iv, 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p38(i8 %val.crude, i8 %start, i8 %extraoffset) {
%entry:
  %val = and i8 %val.crude, 127
  assume i1 1
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct!

-- 3. ModuleToFunctionPassAdaptor

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @p1(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @p2(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n3(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nuw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n4(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n5(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @p6(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i8 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %iv, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %iv.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i7 @p7(i7 %val, i7 %start, i7 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i7 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i7 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i7 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i7 %val.shifted, 0
  assume i1 1
  %iv.next = add i7 %iv, 1
  assume i1 1
  call void @escape_inner.i7(i7 %iv, i7 %nbits, i7 %val.shifted, i1 %val.shifted.iszero, i7 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i7 [ %iv, %loop ]
  %nbits.res = phi i7 [ %nbits, %loop ]
  %val.shifted.res = phi i7 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i7 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i7(i7 %iv.res, i7 %nbits.res, i7 %val.shifted.res, i1 %val.shifted.iszero.res, i7 %iv.next.res)
  ret i7 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n8(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 2
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @t9(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n10(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.isnotzero = icmp ne i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.isnotzero, i8 %iv.next)
  br i1 %val.shifted.isnotzero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.isnotzero.res = phi i1 [ %val.shifted.isnotzero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.isnotzero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n11(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %loop, label %end

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n12(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n13(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop.end ]
  assume i1 1
  br label %loop.end

%loop.end:
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop.end ]
  %nbits.res = phi i8 [ %nbits, %loop.end ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop.end ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop.end ]
  %iv.next.res = phi i8 [ %iv.next, %loop.end ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n14(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp ult i8 %val.shifted, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @t15(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %extraoffset, %iv
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n16(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i8 %extraoffset, %iv
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n17(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %extraoffset = call i8 @gen.i8()
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n18(i8 %val, i8 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %extraoffset = call i8 @gen.i8()
  assume i1 1
  %nbits = sub nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n19(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop.preheader

%loop.preheader:
  %notiv = phi i8 [ 0, %entry ]
  assume i1 1
  br label %loop

%loop:
  %iv = phi i8 [ %start, %loop.preheader ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %notiv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n20(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = add i8 0, 0
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n21(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 0, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n22(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %not.iv.next = add i8 %iv, 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  %also.iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n23(i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val = call i8 @gen.i8()
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @t24_nooffset_i1(i1 %val, i1 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i1 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %iv, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %iv.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i2 @t25_nooffset_i2(i2 %val, i2 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i2 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %iv, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %iv.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i3 @t26_nooffset_i3(i3 %val, i3 %start) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %val.shifted = ashr i3 %val, %iv
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %iv, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %iv.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @t27_addnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i2 @t28_addnsw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i3 @t29_addnsw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @t30_addnuw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i2 @t31_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i3 @t32_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nuw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @t33_subnsw_i1(i1 %val, i1 %start, i1 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i1 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i1 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i1 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i1 %val.shifted, 0
  assume i1 1
  %iv.next = add i1 %iv, 1
  assume i1 1
  call void @escape_inner.i1(i1 %iv, i1 %nbits, i1 %val.shifted, i1 %val.shifted.iszero, i1 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i1 [ %iv, %loop ]
  %nbits.res = phi i1 [ %nbits, %loop ]
  %val.shifted.res = phi i1 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i1 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i1(i1 %iv.res, i1 %nbits.res, i1 %val.shifted.res, i1 %val.shifted.iszero.res, i1 %iv.next.res)
  ret i1 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i2 @t34_addnuw_i2(i2 %val, i2 %start, i2 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i2 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i2 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i2 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i2 %val.shifted, 0
  assume i1 1
  %iv.next = add i2 %iv, 1
  assume i1 1
  call void @escape_inner.i2(i2 %iv, i2 %nbits, i2 %val.shifted, i1 %val.shifted.iszero, i2 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i2 [ %iv, %loop ]
  %nbits.res = phi i2 [ %nbits, %loop ]
  %val.shifted.res = phi i2 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i2 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i2(i2 %iv.res, i2 %nbits.res, i2 %val.shifted.res, i1 %val.shifted.iszero.res, i2 %iv.next.res)
  ret i2 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i3 @t35_addnuw_i3(i3 %val, i3 %start, i3 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i3 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = sub nsw i3 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i3 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i3 %val.shifted, 0
  assume i1 1
  %iv.next = add i3 %iv, 1
  assume i1 1
  call void @escape_inner.i3(i3 %iv, i3 %nbits, i3 %val.shifted, i1 %val.shifted.iszero, i3 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i3 [ %iv, %loop ]
  %nbits.res = phi i3 [ %nbits, %loop ]
  %val.shifted.res = phi i3 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i3 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer.i3(i3 %iv.res, i3 %nbits.res, i3 %val.shifted.res, i1 %val.shifted.iszero.res, i3 %iv.next.res)
  ret i3 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @n36(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @p37(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @p38(i8 %val.crude, i8 %start, i8 %extraoffset) {
%entry:
  %val = and i8 %val.crude, 127
  assume i1 1
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 1. FunctionToLoopPassAdaptor

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 2. PassManager<Function> : Skipping NOP
-- 3. LoopSimplifyPass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 4. LoopSimplifyPass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 5. LCSSAPass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 6. LCSSAPass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 7. PassManager<Function> : Skipping NOP
-- 8. LoopIdiomRecognizePass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation seems to be correct! (syntactically equal)

-- 9. LoopIdiomRecognizePass

----------------------------------------
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  br label %loop

%loop:
  %iv = phi i8 [ %start, %entry ], [ %iv.next, %loop ]
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  %val.shifted.iszero = icmp eq i8 %val.shifted, 0
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %val.shifted.iszero, i8 %iv.next)
  br i1 %val.shifted.iszero, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %val.shifted.iszero, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
=>
define i8 @p0(i8 %val, i8 %start, i8 %extraoffset) {
%entry:
  %val.numleadingzeros = ctlz i8 %val, 0
  %val.numactivebits = sub nsw nuw i8 8, %val.numleadingzeros
  %0 = sub i8 0, %extraoffset
  %val.numactivebits.offset = add nsw i8 %val.numactivebits, %0
  %iv.final = smax i8 %val.numactivebits.offset, %start
  %loop.backedgetakencount = sub nsw i8 %iv.final, %start
  %loop.tripcount = add nsw nuw i8 %loop.backedgetakencount, 1
  br label %loop

%loop:
  %loop.iv = phi i8 [ 0, %entry ], [ %loop.iv.next, %loop ]
  %loop.iv.next = add nsw nuw i8 %loop.iv, 1
  %loop.ivcheck = icmp eq i8 %loop.iv.next, %loop.tripcount
  %iv = add nsw i8 %loop.iv, %start
  assume i1 1
  %nbits = add nsw i8 %iv, %extraoffset
  assume i1 1
  %val.shifted = ashr i8 %val, %nbits
  assume i1 1
  assume i1 1
  %iv.next = add i8 %iv, 1
  assume i1 1
  call void @escape_inner(i8 %iv, i8 %nbits, i8 %val.shifted, i1 %loop.ivcheck, i8 %iv.next)
  br i1 %loop.ivcheck, label %end, label %loop

%end:
  %iv.res = phi i8 [ %iv.final, %loop ]
  %nbits.res = phi i8 [ %nbits, %loop ]
  %val.shifted.res = phi i8 [ %val.shifted, %loop ]
  %val.shifted.iszero.res = phi i1 [ %loop.ivcheck, %loop ]
  %iv.next.res = phi i8 [ %iv.next, %loop ]
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  assume i1 1
  call void @escape_outer(i8 %iv.res, i8 %nbits.res, i8 %val.shifted.res, i1 %val.shifted.iszero.res, i8 %iv.next.res)
  ret i8 %iv.res
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
i8 %val = undef
i8 %start = #x78 (120)
i8 %extraoffset = #x88 (136, -120)

Source:
  >> Jump to %loop
i8 %iv = #x78 (120)
i8 %nbits = #x00 (0)
i8 %val.shifted = #x00 (0)	[based on undef value]
i1 %val.shifted.iszero = #x1 (1)
i8 %iv.next = #x79 (121)
void = function did not return!

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0
Block 1 >	size: 0	align: 1	alloc type: 0

Target:
i8 %val.numleadingzeros = #x04 (4)
i8 %val.numactivebits = #x04 (4)
i8 %0 = #x78 (120)
i8 %val.numactivebits.offset = #x7c (124)
i8 %iv.final = #x7c (124)
i8 %loop.backedgetakencount = #x04 (4)
i8 %loop.tripcount = #x05 (5)
  >> Jump to %loop
i8 %loop.iv = #x00 (0)
i8 %loop.iv.next = #x01 (1)
i1 %loop.ivcheck = #x0 (0)
i8 %iv = #x78 (120)
i8 %nbits = #x00 (0)
i8 %val.shifted = #x1e (30)
i8 %iv.next = #x79 (121)
void = function did not return!


Pass: LoopIdiomRecognizePass
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' '-passes=debugify,loop-idiom' '-mtriple=x86_64' '-mcpu=core-avx2' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_nOrwAeT1_mtFl.bc"


------------------- SMT STATS -------------------
Num queries: 270
Num invalid: 0
Num skips:   0
Num trivial: 52 (16.1%)
Num timeout: 11 (4.1%)
Num errors:  0 (0.0%)
Num SAT:     121 (44.8%)
Num UNSAT:   138 (51.1%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -passes=debugify,loop-idiom -mtriple=x86_64 -mcpu=corei7 -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck --check-prefixes=CHECK,NOLZCNT /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopIdiom/X86/arithmetic-right-shift-until-zero.ll
+ : 'RUN: at line 3'
+ /bitbucket/nlopes/llvm/build/bin/FileCheck --check-prefixes=CHECK,LZCNT /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopIdiom/X86/arithmetic-right-shift-until-zero.ll
+ /home/nlopes/alive2/build/opt-alive.sh -passes=debugify,loop-idiom -mtriple=x86_64 -mcpu=core-avx2 -S

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck --check-prefixes=CHECK,LZCNT /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopIdiom/X86/arithmetic-right-shift-until-zero.ll

<-- Back