Remove llvm-upgrade and update test cases.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47793 91177308-0d34-0410-b5e6-96231b3b80d8

86 files changed, 3042 insertions, 2979 deletions

diff --git a/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll b/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll
index dd683a3d99..94ce68e989 100644
--- a/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll
+++ b/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll
@@ -1,11 +1,9 @@
 ; This testcase causes instcombine to hang.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
+; RUN: llvm-as < %s | opt -instcombine
 
-implementation
+define void @test(i32 %X) {
+        %reg117 = add i32 %X, 0         ; <i32> [#uses=0]
+        ret void
+}
 
-void "test"(int %X)
-begin
-	%reg117 = add int %X, 0
-	ret void
-end
diff --git a/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll b/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll
index 5e6d63bdd0..1c93d2457d 100644
--- a/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll
+++ b/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll
@@ -1,510 +1,506 @@
-; This testcase, obviously distilled from a large program (bzip2 from 
-; Specint2000) caused instcombine to fail because it got the same instruction 
-; on it's worklist more than once (which is ok), but then deleted the 
-; instruction.  Since the inst stayed on the worklist, as soon as it came back 
+; This testcase, obviously distilled from a large program (bzip2 from
+; Specint2000) caused instcombine to fail because it got the same instruction
+; on it's worklist more than once (which is ok), but then deleted the
+; instruction.  Since the inst stayed on the worklist, as soon as it came back
 ; up to be processed, bad things happened, and opt asserted.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
-; END.
+; RUN: llvm-as < %s | opt -instcombine
 ;
-
-%.LC0 = internal global [21 x sbyte] c"hbMakeCodeLengths(1)\00"		; <[21 x sbyte]*> [#uses=1]
-%.LC1 = internal global [21 x sbyte] c"hbMakeCodeLengths(2)\00"		; <[21 x sbyte]*> [#uses=1]
-
-implementation   ; Functions:
-
-void %hbMakeCodeLengths(ubyte* %len, int* %freq, int %alphaSize, int %maxLen) {
-bb0:					;[#uses=0]
-	%len = alloca ubyte*		; <ubyte**> [#uses=2]
-	store ubyte* %len, ubyte** %len
-	%freq = alloca int*		; <int**> [#uses=2]
-	store int* %freq, int** %freq
-	%alphaSize = alloca int		; <int*> [#uses=2]
-	store int %alphaSize, int* %alphaSize
-	%maxLen = alloca int		; <int*> [#uses=2]
-	store int %maxLen, int* %maxLen
-	%heap = alloca int, uint 260		; <int*> [#uses=27]
-	%weight = alloca int, uint 516		; <int*> [#uses=18]
-	%parent = alloca int, uint 516		; <int*> [#uses=7]
+@.LC0 = internal global [21 x i8] c"hbMakeCodeLengths(1)\00"		; <[21 x i8]*> [#uses=1]
+@.LC1 = internal global [21 x i8] c"hbMakeCodeLengths(2)\00"		; <[21 x i8]*> [#uses=1]
+
+define void @hbMakeCodeLengths(i8* %len, i32* %freq, i32 %alphaSize, i32 %maxLen) {
+bb0:
+	%len.upgrd.1 = alloca i8*		; <i8**> [#uses=2]
+	store i8* %len, i8** %len.upgrd.1
+	%freq.upgrd.2 = alloca i32*		; <i32**> [#uses=2]
+	store i32* %freq, i32** %freq.upgrd.2
+	%alphaSize.upgrd.3 = alloca i32		; <i32*> [#uses=2]
+	store i32 %alphaSize, i32* %alphaSize.upgrd.3
+	%maxLen.upgrd.4 = alloca i32		; <i32*> [#uses=2]
+	store i32 %maxLen, i32* %maxLen.upgrd.4
+	%heap = alloca i32, i32 260		; <i32*> [#uses=27]
+	%weight = alloca i32, i32 516		; <i32*> [#uses=18]
+	%parent = alloca i32, i32 516		; <i32*> [#uses=7]
 	br label %bb1
 
-bb1:					;[#uses=2]
-	%reg107 = load ubyte** %len		; <ubyte*> [#uses=1]
-	%reg108 = load int** %freq		; <int*> [#uses=1]
-	%reg109 = load int* %alphaSize		; <int> [#uses=10]
-	%reg110 = load int* %maxLen		; <int> [#uses=1]
-	%cond747 = setge int 0, %reg109		; <bool> [#uses=1]
-	br bool %cond747, label %bb6, label %bb2
-
-bb2:					;[#uses=2]
-	%reg591 = phi int [ %reg594, %bb5 ], [ 0, %bb1 ]		; <int> [#uses=3]
-	%reg591-idxcast1 = cast int %reg591 to uint		; <uint> [#uses=1]
-	%reg591-idxcast1-offset = add uint %reg591-idxcast1, 1		; <uint> [#uses=1]
-	%reg591-idxcast1-offset = cast uint %reg591-idxcast1-offset to long		; <long> [#uses=1]
-	%reg126 = getelementptr int* %weight, long %reg591-idxcast1-offset		; <int*> [#uses=1]
-	%reg591-idxcast = cast int %reg591 to long		; <long> [#uses=1]
-	%reg132 = getelementptr int* %reg108, long %reg591-idxcast		; <int*> [#uses=1]
-	%reg133 = load int* %reg132		; <int> [#uses=2]
-	%cond748 = seteq int %reg133, 0		; <bool> [#uses=1]
-	br bool %cond748, label %bb4, label %bb3
-
-bb3:					;[#uses=2]
-	%reg127 = shl int %reg133, ubyte 8		; <int> [#uses=1]
+bb1:		; preds = %bb0
+	%reg107 = load i8** %len.upgrd.1		; <i8*> [#uses=1]
+	%reg108 = load i32** %freq.upgrd.2		; <i32*> [#uses=1]
+	%reg109 = load i32* %alphaSize.upgrd.3		; <i32> [#uses=10]
+	%reg110 = load i32* %maxLen.upgrd.4		; <i32> [#uses=1]
+	%cond747 = icmp sge i32 0, %reg109		; <i1> [#uses=1]
+	br i1 %cond747, label %bb6, label %bb2
+
+bb2:		; preds = %bb5, %bb1
+	%reg591 = phi i32 [ %reg594, %bb5 ], [ 0, %bb1 ]		; <i32> [#uses=3]
+	%reg591-idxcast1 = bitcast i32 %reg591 to i32		; <i32> [#uses=1]
+	%reg591-idxcast1-offset = add i32 %reg591-idxcast1, 1		; <i32> [#uses=1]
+	%reg591-idxcast1-offset.upgrd.5 = zext i32 %reg591-idxcast1-offset to i64		; <i64> [#uses=1]
+	%reg126 = getelementptr i32* %weight, i64 %reg591-idxcast1-offset.upgrd.5		; <i32*> [#uses=1]
+	%reg591-idxcast = sext i32 %reg591 to i64		; <i64> [#uses=1]
+	%reg132 = getelementptr i32* %reg108, i64 %reg591-idxcast		; <i32*> [#uses=1]
+	%reg133 = load i32* %reg132		; <i32> [#uses=2]
+	%cond748 = icmp eq i32 %reg133, 0		; <i1> [#uses=1]
+	br i1 %cond748, label %bb4, label %bb3
+
+bb3:		; preds = %bb2
+	%reg127 = shl i32 %reg133, 8		; <i32> [#uses=1]
 	br label %bb5
 
-bb4:					;[#uses=2]
+bb4:		; preds = %bb2
 	br label %bb5
 
-bb5:					;[#uses=3]
-	%reg593 = phi int [ 256, %bb4 ], [ %reg127, %bb3 ]		; <int> [#uses=1]
-	store int %reg593, int* %reg126
-	%reg594 = add int %reg591, 1		; <int> [#uses=2]
-	%cond749 = setlt int %reg594, %reg109		; <bool> [#uses=1]
-	br bool %cond749, label %bb2, label %bb6
-
-bb6:					;[#uses=6]
-	store int 0, int* %heap
-	store int 0, int* %weight
-	store int -2, int* %parent
-	%cond750 = setgt int 1, %reg109		; <bool> [#uses=1]
-	br bool %cond750, label %bb11, label %bb7
-
-bb7:					;[#uses=3]
-	%reg597 = phi uint [ %reg598, %bb10 ], [ 0, %bb6 ]		; <uint> [#uses=5]
-	%reg597-casted = cast uint %reg597 to int		; <int> [#uses=1]
-	%reg596 = add int %reg597-casted, 1		; <int> [#uses=3]
-	%reg597-offset = add uint %reg597, 1		; <uint> [#uses=1]
-	%reg597-offset = cast uint %reg597-offset to long		; <long> [#uses=1]
-	%reg149 = getelementptr int* %parent, long %reg597-offset		; <int*> [#uses=1]
-	store int -1, int* %reg149
-	%reg598 = add uint %reg597, 1		; <uint> [#uses=3]
-	%reg597-offset1 = add uint %reg597, 1		; <uint> [#uses=1]
-	%reg597-offset1 = cast uint %reg597-offset1 to long		; <long> [#uses=1]
-	%reg157 = getelementptr int* %heap, long %reg597-offset1		; <int*> [#uses=1]
-	store int %reg596, int* %reg157
+bb5:		; preds = %bb4, %bb3
+	%reg593 = phi i32 [ 256, %bb4 ], [ %reg127, %bb3 ]		; <i32> [#uses=1]
+	store i32 %reg593, i32* %reg126
+	%reg594 = add i32 %reg591, 1		; <i32> [#uses=2]
+	%cond749 = icmp slt i32 %reg594, %reg109		; <i1> [#uses=1]
+	br i1 %cond749, label %bb2, label %bb6
+
+bb6:		; preds = %bb43, %bb41, %bb5, %bb1
+	store i32 0, i32* %heap
+	store i32 0, i32* %weight
+	store i32 -2, i32* %parent
+	%cond750 = icmp sgt i32 1, %reg109		; <i1> [#uses=1]
+	br i1 %cond750, label %bb11, label %bb7
+
+bb7:		; preds = %bb10, %bb6
+	%reg597 = phi i32 [ %reg598, %bb10 ], [ 0, %bb6 ]		; <i32> [#uses=5]
+	%reg597-casted = bitcast i32 %reg597 to i32		; <i32> [#uses=1]
+	%reg596 = add i32 %reg597-casted, 1		; <i32> [#uses=3]
+	%reg597-offset = add i32 %reg597, 1		; <i32> [#uses=1]
+	%reg597-offset.upgrd.6 = zext i32 %reg597-offset to i64		; <i64> [#uses=1]
+	%reg149 = getelementptr i32* %parent, i64 %reg597-offset.upgrd.6		; <i32*> [#uses=1]
+	store i32 -1, i32* %reg149
+	%reg598 = add i32 %reg597, 1		; <i32> [#uses=3]
+	%reg597-offset1 = add i32 %reg597, 1		; <i32> [#uses=1]
+	%reg597-offset1.upgrd.7 = zext i32 %reg597-offset1 to i64		; <i64> [#uses=1]
+	%reg157 = getelementptr i32* %heap, i64 %reg597-offset1.upgrd.7		; <i32*> [#uses=1]
+	store i32 %reg596, i32* %reg157
 	br label %bb9
 
-bb8:					;[#uses=2]
-	%reg599 = cast uint %reg599 to long		; <long> [#uses=1]
-	%reg198 = getelementptr int* %heap, long %reg599		; <int*> [#uses=1]
-	store int %reg182, int* %reg198
-	%cast938 = cast int %reg174 to uint		; <uint> [#uses=1]
+bb8:		; preds = %bb9
+	%reg599 = zext i32 %reg599.upgrd.8 to i64		; <i64> [#uses=1]
+	%reg198 = getelementptr i32* %heap, i64 %reg599		; <i32*> [#uses=1]
+	store i32 %reg182, i32* %reg198
+	%cast938 = bitcast i32 %reg174 to i32		; <i32> [#uses=1]
 	br label %bb9
 
-bb9:					;[#uses=2]
-	%reg599 = phi uint [ %cast938, %bb8 ], [ %reg598, %bb7 ]		; <uint> [#uses=3]
-	%cast807 = cast uint %reg599 to int		; <int> [#uses=1]
-	%reg597-offset2 = add uint %reg597, 1		; <uint> [#uses=1]
-	%reg597-offset2 = cast uint %reg597-offset2 to long		; <long> [#uses=1]
-	%reg173 = getelementptr int* %weight, long %reg597-offset2		; <int*> [#uses=1]
-	%reg174 = shr int %cast807, ubyte 1		; <int> [#uses=2]
-	%reg174-idxcast = cast int %reg174 to uint		; <uint> [#uses=1]
-	cast uint %reg174-idxcast to long		; <long>:0 [#uses=1]
-	%reg181 = getelementptr int* %heap, long %0		; <int*> [#uses=1]
-	%reg182 = load int* %reg181		; <int> [#uses=2]
-	%reg182-idxcast = cast int %reg182 to uint		; <uint> [#uses=1]
-	cast uint %reg182-idxcast to long		; <long>:1 [#uses=1]
-	%reg189 = getelementptr int* %weight, long %1		; <int*> [#uses=1]
-	%reg190 = load int* %reg173		; <int> [#uses=1]
-	%reg191 = load int* %reg189		; <int> [#uses=1]
-	%cond751 = setlt int %reg190, %reg191		; <bool> [#uses=1]
-	br bool %cond751, label %bb8, label %bb10
-
-bb10:					;[#uses=3]
-	cast uint %reg599 to long		; <long>:2 [#uses=1]
-	%reg214 = getelementptr int* %heap, long %2		; <int*> [#uses=1]
-	store int %reg596, int* %reg214
-	%reg601 = add int %reg596, 1		; <int> [#uses=1]
-	%cond752 = setle int %reg601, %reg109		; <bool> [#uses=1]
-	br bool %cond752, label %bb7, label %bb11
-
-bb11:					;[#uses=2]
-	%reg602 = phi uint [ %reg598, %bb10 ], [ 0, %bb6 ]		; <uint> [#uses=3]
-	%cast819 = cast uint %reg602 to int		; <int> [#uses=1]
-	%cast818 = cast uint %reg602 to int		; <int> [#uses=1]
-	%cond753 = setle int %cast818, 259		; <bool> [#uses=1]
-	br bool %cond753, label %bb13, label %bb12
-
-bb12:					;[#uses=1]
-	cast uint 0 to long		; <long>:3 [#uses=1]
-	cast uint 0 to long		; <long>:4 [#uses=1]
-	%cast784 = getelementptr [21 x sbyte]* %.LC0, long %3, long %4		; <sbyte*> [#uses=1]
-	call void %panic( sbyte* %cast784 )
+bb9:		; preds = %bb8, %bb7
+	%reg599.upgrd.8 = phi i32 [ %cast938, %bb8 ], [ %reg598, %bb7 ]		; <i32> [#uses=3]
+	%cast807 = bitcast i32 %reg599.upgrd.8 to i32		; <i32> [#uses=1]
+	%reg597-offset2 = add i32 %reg597, 1		; <i32> [#uses=1]
+	%reg597-offset2.upgrd.9 = zext i32 %reg597-offset2 to i64		; <i64> [#uses=1]
+	%reg173 = getelementptr i32* %weight, i64 %reg597-offset2.upgrd.9		; <i32*> [#uses=1]
+	%reg174 = ashr i32 %cast807, 1		; <i32> [#uses=2]
+	%reg174-idxcast = bitcast i32 %reg174 to i32		; <i32> [#uses=1]
+	zext i32 %reg174-idxcast to i64		; <i64>:0 [#uses=1]
+	%reg181 = getelementptr i32* %heap, i64 %0		; <i32*> [#uses=1]
+	%reg182 = load i32* %reg181		; <i32> [#uses=2]
+	%reg182-idxcast = bitcast i32 %reg182 to i32		; <i32> [#uses=1]
+	zext i32 %reg182-idxcast to i64		; <i64>:1 [#uses=1]
+	%reg189 = getelementptr i32* %weight, i64 %1		; <i32*> [#uses=1]
+	%reg190 = load i32* %reg173		; <i32> [#uses=1]
+	%reg191 = load i32* %reg189		; <i32> [#uses=1]
+	%cond751 = icmp slt i32 %reg190, %reg191		; <i1> [#uses=1]
+	br i1 %cond751, label %bb8, label %bb10
+
+bb10:		; preds = %bb9
+	zext i32 %reg599.upgrd.8 to i64		; <i64>:2 [#uses=1]
+	%reg214 = getelementptr i32* %heap, i64 %2		; <i32*> [#uses=1]
+	store i32 %reg596, i32* %reg214
+	%reg601 = add i32 %reg596, 1		; <i32> [#uses=1]
+	%cond752 = icmp sle i32 %reg601, %reg109		; <i1> [#uses=1]
+	br i1 %cond752, label %bb7, label %bb11
+
+bb11:		; preds = %bb10, %bb6
+	%reg602 = phi i32 [ %reg598, %bb10 ], [ 0, %bb6 ]		; <i32> [#uses=3]
+	%cast819 = bitcast i32 %reg602 to i32		; <i32> [#uses=1]
+	%cast818 = bitcast i32 %reg602 to i32		; <i32> [#uses=1]
+	%cond753 = icmp sle i32 %cast818, 259		; <i1> [#uses=1]
+	br i1 %cond753, label %bb13, label %bb12
+
+bb12:		; preds = %bb11
+	zext i32 0 to i64		; <i64>:3 [#uses=1]
+	zext i32 0 to i64		; <i64>:4 [#uses=1]
+	%cast784 = getelementptr [21 x i8]* @.LC0, i64 %3, i64 %4		; <i8*> [#uses=1]
+	call void @panic( i8* %cast784 )
 	br label %bb13
 
-bb13:					;[#uses=4]
-	%cond754 = setle int %cast819, 1		; <bool> [#uses=1]
-	%cast918 = cast int %reg109 to uint		; <uint> [#uses=1]
-	%cast940 = cast uint %reg602 to int		; <int> [#uses=1]
-	%cast942 = cast int %reg109 to uint		; <uint> [#uses=1]
-	br bool %cond754, label %bb32, label %bb14
-
-bb14:					;[#uses=5]
-	%cann-indvar1 = phi uint [ 0, %bb13 ], [ %add1-indvar1, %bb31 ]		; <uint> [#uses=3]
-	%cann-indvar1-casted = cast uint %cann-indvar1 to int		; <int> [#uses=1]
-	%reg603-scale = mul int %cann-indvar1-casted, -1		; <int> [#uses=1]
-	%reg603 = add int %reg603-scale, %cast940		; <int> [#uses=4]
-	%reg604 = add uint %cann-indvar1, %cast942		; <uint> [#uses=4]
-	%add1-indvar1 = add uint %cann-indvar1, 1		; <uint> [#uses=1]
-	cast uint 1 to long		; <long>:5 [#uses=1]
-	%reg7551 = getelementptr int* %heap, long %5		; <int*> [#uses=1]
-	%reg113 = load int* %reg7551		; <int> [#uses=2]
-	%reg603-idxcast = cast int %reg603 to uint		; <uint> [#uses=1]
-	cast uint %reg603-idxcast to long		; <long>:6 [#uses=1]
-	%reg222 = getelementptr int* %heap, long %6		; <int*> [#uses=1]
-	%reg223 = load int* %reg222		; <int> [#uses=1]
-	cast uint 1 to long		; <long>:7 [#uses=1]
-	%reg7561 = getelementptr int* %heap, long %7		; <int*> [#uses=1]
-	store int %reg223, int* %reg7561
-	%reg605 = add int %reg603, -1		; <int> [#uses=4]
-	cast uint 1 to long		; <long>:8 [#uses=1]
-	%reg757 = getelementptr int* %heap, long %8		; <int*> [#uses=1]
-	%reg226 = load int* %reg757		; <int> [#uses=2]
-	%cond758 = setgt int 2, %reg605		; <bool> [#uses=1]
-	br bool %cond758, label %bb20, label %bb15
-
-bb15:					;[#uses=3]
-	%reg606 = phi int [ %reg611, %bb19 ], [ 2, %bb14 ]		; <int> [#uses=6]
-	%reg607 = phi int [ %reg609, %bb19 ], [ 1, %bb14 ]		; <int> [#uses=2]
-	%cond759 = setge int %reg606, %reg605		; <bool> [#uses=1]
-	br bool %cond759, label %bb18, label %bb16
-
-bb16:					;[#uses=2]
-	%reg606-idxcast = cast int %reg606 to uint		; <uint> [#uses=1]
-	%reg606-idxcast-offset = add uint %reg606-idxcast, 1		; <uint> [#uses=1]
-	cast uint %reg606-idxcast-offset to long		; <long>:9 [#uses=1]
-	%reg241 = getelementptr int* %heap, long %9		; <int*> [#uses=1]
-	%reg242 = load int* %reg241		; <int> [#uses=1]
-	%reg242-idxcast = cast int %reg242 to uint		; <uint> [#uses=1]
-	cast uint %reg242-idxcast to long		; <long>:10 [#uses=1]
-	%reg249 = getelementptr int* %weight, long %10		; <int*> [#uses=1]
-	%reg606-idxcast1 = cast int %reg606 to uint		; <uint> [#uses=1]
-	cast uint %reg606-idxcast1 to long		; <long>:11 [#uses=1]
-	%reg256 = getelementptr int* %heap, long %11		; <int*> [#uses=1]
-	%reg257 = load int* %reg256		; <int> [#uses=1]
-	%reg257-idxcast = cast int %reg257 to uint		; <uint> [#uses=1]
-	cast uint %reg257-idxcast to long		; <long>:12 [#uses=1]
-	%reg264 = getelementptr int* %weight, long %12		; <int*> [#uses=1]
-	%reg265 = load int* %reg249		; <int> [#uses=1]
-	%reg266 = load int* %reg264		; <int> [#uses=1]
-	%cond760 = setge int %reg265, %reg266		; <bool> [#uses=1]
-	br bool %cond760, label %bb18, label %bb17
-
-bb17:					;[#uses=2]
-	%reg608 = add int %reg606, 1		; <int> [#uses=1]
+bb13:		; preds = %bb12, %bb11
+	%cond754 = icmp sle i32 %cast819, 1		; <i1> [#uses=1]
+	%cast918 = bitcast i32 %reg109 to i32		; <i32> [#uses=1]
+	%cast940 = bitcast i32 %reg602 to i32		; <i32> [#uses=1]
+	%cast942 = bitcast i32 %reg109 to i32		; <i32> [#uses=1]
+	br i1 %cond754, label %bb32, label %bb14
+
+bb14:		; preds = %bb31, %bb13
+	%cann-indvar1 = phi i32 [ 0, %bb13 ], [ %add1-indvar1, %bb31 ]		; <i32> [#uses=3]
+	%cann-indvar1-casted = bitcast i32 %cann-indvar1 to i32		; <i32> [#uses=1]
+	%reg603-scale = mul i32 %cann-indvar1-casted, -1		; <i32> [#uses=1]
+	%reg603 = add i32 %reg603-scale, %cast940		; <i32> [#uses=4]
+	%reg604 = add i32 %cann-indvar1, %cast942		; <i32> [#uses=4]
+	%add1-indvar1 = add i32 %cann-indvar1, 1		; <i32> [#uses=1]
+	zext i32 1 to i64		; <i64>:5 [#uses=1]
+	%reg7551 = getelementptr i32* %heap, i64 %5		; <i32*> [#uses=1]
+	%reg113 = load i32* %reg7551		; <i32> [#uses=2]
+	%reg603-idxcast = bitcast i32 %reg603 to i32		; <i32> [#uses=1]
+	zext i32 %reg603-idxcast to i64		; <i64>:6 [#uses=1]
+	%reg222 = getelementptr i32* %heap, i64 %6		; <i32*> [#uses=1]
+	%reg223 = load i32* %reg222		; <i32> [#uses=1]
+	zext i32 1 to i64		; <i64>:7 [#uses=1]
+	%reg7561 = getelementptr i32* %heap, i64 %7		; <i32*> [#uses=1]
+	store i32 %reg223, i32* %reg7561
+	%reg605 = add i32 %reg603, -1		; <i32> [#uses=4]
+	zext i32 1 to i64		; <i64>:8 [#uses=1]
+	%reg757 = getelementptr i32* %heap, i64 %8		; <i32*> [#uses=1]
+	%reg226 = load i32* %reg757		; <i32> [#uses=2]
+	%cond758 = icmp sgt i32 2, %reg605		; <i1> [#uses=1]
+	br i1 %cond758, label %bb20, label %bb15
+
+bb15:		; preds = %bb19, %bb14
+	%reg606 = phi i32 [ %reg611, %bb19 ], [ 2, %bb14 ]		; <i32> [#uses=6]
+	%reg607 = phi i32 [ %reg609, %bb19 ], [ 1, %bb14 ]		; <i32> [#uses=2]
+	%cond759 = icmp sge i32 %reg606, %reg605		; <i1> [#uses=1]
+	br i1 %cond759, label %bb18, label %bb16
+
+bb16:		; preds = %bb15
+	%reg606-idxcast = bitcast i32 %reg606 to i32		; <i32> [#uses=1]
+	%reg606-idxcast-offset = add i32 %reg606-idxcast, 1		; <i32> [#uses=1]
+	zext i32 %reg606-idxcast-offset to i64		; <i64>:9 [#uses=1]
+	%reg241 = getelementptr i32* %heap, i64 %9		; <i32*> [#uses=1]
+	%reg242 = load i32* %reg241		; <i32> [#uses=1]
+	%reg242-idxcast = bitcast i32 %reg242 to i32		; <i32> [#uses=1]
+	zext i32 %reg242-idxcast to i64		; <i64>:10 [#uses=1]
+	%reg249 = getelementptr i32* %weight, i64 %10		; <i32*> [#uses=1]
+	%reg606-idxcast1 = bitcast i32 %reg606 to i32		; <i32> [#uses=1]
+	zext i32 %reg606-idxcast1 to i64		; <i64>:11 [#uses=1]
+	%reg256 = getelementptr i32* %heap, i64 %11		; <i32*> [#uses=1]
+	%reg257 = load i32* %reg256		; <i32> [#uses=1]
+	%reg257-idxcast = bitcast i32 %reg257 to i32		; <i32> [#uses=1]
+	zext i32 %reg257-idxcast to i64		; <i64>:12 [#uses=1]
+	%reg264 = getelementptr i32* %weight, i64 %12		; <i32*> [#uses=1]
+	%reg265 = load i32* %reg249		; <i32> [#uses=1]
+	%reg266 = load i32* %reg264		; <i32> [#uses=1]
+	%cond760 = icmp sge i32 %reg265, %reg266		; <i1> [#uses=1]
+	br i1 %cond760, label %bb18, label %bb17
+
+bb17:		; preds = %bb16
+	%reg608 = add i32 %reg606, 1		; <i32> [#uses=1]
 	br label %bb18
 
-bb18:					;[#uses=4]
-	%reg609 = phi int [ %reg608, %bb17 ], [ %reg606, %bb16 ], [ %reg606, %bb15 ]		; <int> [#uses=4]
-	%reg226-idxcast = cast int %reg226 to uint		; <uint> [#uses=1]
-	cast uint %reg226-idxcast to long		; <long>:13 [#uses=1]
-	%reg273 = getelementptr int* %weight, long %13		; <int*> [#uses=1]
-	%reg609-idxcast = cast int %reg609 to uint		; <uint> [#uses=1]
-	cast uint %reg609-idxcast to long		; <long>:14 [#uses=1]
-	%reg280 = getelementptr int* %heap, long %14		; <int*> [#uses=1]
-	%reg281 = load int* %reg280		; <int> [#uses=2]
-	%reg281-idxcast = cast int %reg281 to uint		; <uint> [#uses=1]
-	cast uint %reg281-idxcast to long		; <long>:15 [#uses=1]
-	%reg288 = getelementptr int* %weight, long %15		; <int*> [#uses=1]
-	%reg289 = load int* %reg273		; <int> [#uses=1]
-	%reg290 = load int* %reg288		; <int> [#uses=1]
-	%cond761 = setlt int %reg289, %reg290		; <bool> [#uses=1]
-	br bool %cond761, label %bb20, label %bb19
-
-bb19:					;[#uses=4]
-	%reg607-idxcast = cast int %reg607 to uint		; <uint> [#uses=1]
-	cast uint %reg607-idxcast to long		; <long>:16 [#uses=1]
-	%reg297 = getelementptr int* %heap, long %16		; <int*> [#uses=1]
-	store int %reg281, int* %reg297
-	%reg611 = shl int %reg609, ubyte 1		; <int> [#uses=2]
-	%cond762 = setle int %reg611, %reg605		; <bool> [#uses=1]
-	br bool %cond762, label %bb15, label %bb20
-
-bb20:					;[#uses=6]
-	%reg612 = phi int [ %reg609, %bb19 ], [ %reg607, %bb18 ], [ 1, %bb14 ]		; <int> [#uses=1]
-	%reg612-idxcast = cast int %reg612 to uint		; <uint> [#uses=1]
-	cast uint %reg612-idxcast to long		; <long>:17 [#uses=1]
-	%reg312 = getelementptr int* %heap, long %17		; <int*> [#uses=1]
-	store int %reg226, int* %reg312
-	cast uint 1 to long		; <long>:18 [#uses=1]
-	%reg7631 = getelementptr int* %heap, long %18		; <int*> [#uses=1]
-	%reg114 = load int* %reg7631		; <int> [#uses=2]
-	%reg603-idxcast1 = cast int %reg603 to uint		; <uint> [#uses=1]
-	%reg603-idxcast1-offset = add uint %reg603-idxcast1, 1073741823		; <uint> [#uses=1]
-	cast uint %reg603-idxcast1-offset to long		; <long>:19 [#uses=1]
-	%reg319 = getelementptr int* %heap, long %19		; <int*> [#uses=1]
-	%reg320 = load int* %reg319		; <int> [#uses=1]
-	cast uint 1 to long		; <long>:20 [#uses=1]
-	%reg7641 = getelementptr int* %heap, long %20		; <int*> [#uses=1]
-	store int %reg320, int* %reg7641
-	%reg613 = add int %reg605, -1		; <int> [#uses=4]
-	cast uint 1 to long		; <long>:21 [#uses=1]
-	%reg765 = getelementptr int* %heap, long %21		; <int*> [#uses=1]
-	%reg323 = load int* %reg765		; <int> [#uses=2]
-	%cond766 = setgt int 2, %reg613		; <bool> [#uses=1]
-	br bool %cond766, label %bb26, label %bb21
-
-bb21:					;[#uses=3]
-	%reg614 = phi int [ %reg619, %bb25 ], [ 2, %bb20 ]		; <int> [#uses=6]
-	%reg615 = phi int [ %reg617, %bb25 ], [ 1, %bb20 ]		; <int> [#uses=2]
-	%cond767 = setge int %reg614, %reg613		; <bool> [#uses=1]
-	br bool %cond767, label %bb24, label %bb22
-
-bb22:					;[#uses=2]
-	%reg614-idxcast = cast int %reg614 to uint		; <uint> [#uses=1]
-	%reg614-idxcast-offset = add uint %reg614-idxcast, 1		; <uint> [#uses=1]
-	cast uint %reg614-idxcast-offset to long		; <long>:22 [#uses=1]
-	%reg338 = getelementptr int* %heap, long %22		; <int*> [#uses=1]
-	%reg339 = load int* %reg338		; <int> [#uses=1]
-	%reg339-idxcast = cast int %reg339 to uint		; <uint> [#uses=1]
-	cast uint %reg339-idxcast to long		; <long>:23 [#uses=1]
-	%reg346 = getelementptr int* %weight, long %23		; <int*> [#uses=1]
-	%reg614-idxcast1 = cast int %reg614 to uint		; <uint> [#uses=1]
-	cast uint %reg614-idxcast1 to long		; <long>:24 [#uses=1]
-	%reg353 = getelementptr int* %heap, long %24		; <int*> [#uses=1]
-	%reg354 = load int* %reg353		; <int> [#uses=1]
-	%reg354-idxcast = cast int %reg354 to uint		; <uint> [#uses=1]
-	cast uint %reg354-idxcast to long		; <long>:25 [#uses=1]
-	%reg361 = getelementptr int* %weight, long %25		; <int*> [#uses=1]
-	%reg362 = load int* %reg346		; <int> [#uses=1]
-	%reg363 = load int* %reg361		; <int> [#uses=1]
-	%cond768 = setge int %reg362, %reg363		; <bool> [#uses=1]
-	br bool %cond768, label %bb24, label %bb23
-
-bb23:					;[#uses=2]
-	%reg616 = add int %reg614, 1		; <int> [#uses=1]
+bb18:		; preds = %bb17, %bb16, %bb15
+	%reg609 = phi i32 [ %reg608, %bb17 ], [ %reg606, %bb16 ], [ %reg606, %bb15 ]		; <i32> [#uses=4]
+	%reg226-idxcast = bitcast i32 %reg226 to i32		; <i32> [#uses=1]
+	zext i32 %reg226-idxcast to i64		; <i64>:13 [#uses=1]
+	%reg273 = getelementptr i32* %weight, i64 %13		; <i32*> [#uses=1]
+	%reg609-idxcast = bitcast i32 %reg609 to i32		; <i32> [#uses=1]
+	zext i32 %reg609-idxcast to i64		; <i64>:14 [#uses=1]
+	%reg280 = getelementptr i32* %heap, i64 %14		; <i32*> [#uses=1]
+	%reg281 = load i32* %reg280		; <i32> [#uses=2]
+	%reg281-idxcast = bitcast i32 %reg281 to i32		; <i32> [#uses=1]
+	zext i32 %reg281-idxcast to i64		; <i64>:15 [#uses=1]
+	%reg288 = getelementptr i32* %weight, i64 %15		; <i32*> [#uses=1]
+	%reg289 = load i32* %reg273		; <i32> [#uses=1]
+	%reg290 = load i32* %reg288		; <i32> [#uses=1]
+	%cond761 = icmp slt i32 %reg289, %reg290		; <i1> [#uses=1]
+	br i1 %cond761, label %bb20, label %bb19
+
+bb19:		; preds = %bb18
+	%reg607-idxcast = bitcast i32 %reg607 to i32		; <i32> [#uses=1]
+	zext i32 %reg607-idxcast to i64		; <i64>:16 [#uses=1]
+	%reg297 = getelementptr i32* %heap, i64 %16		; <i32*> [#uses=1]
+	store i32 %reg281, i32* %reg297
+	%reg611 = shl i32 %reg609, 1		; <i32> [#uses=2]
+	%cond762 = icmp sle i32 %reg611, %reg605		; <i1> [#uses=1]
+	br i1 %cond762, label %bb15, label %bb20
+
+bb20:		; preds = %bb19, %bb18, %bb14
+	%reg612 = phi i32 [ %reg609, %bb19 ], [ %reg607, %bb18 ], [ 1, %bb14 ]		; <i32> [#uses=1]
+	%reg612-idxcast = bitcast i32 %reg612 to i32		; <i32> [#uses=1]
+	zext i32 %reg612-idxcast to i64		; <i64>:17 [#uses=1]
+	%reg312 = getelementptr i32* %heap, i64 %17		; <i32*> [#uses=1]
+	store i32 %reg226, i32* %reg312
+	zext i32 1 to i64		; <i64>:18 [#uses=1]
+	%reg7631 = getelementptr i32* %heap, i64 %18		; <i32*> [#uses=1]
+	%reg114 = load i32* %reg7631		; <i32> [#uses=2]
+	%reg603-idxcast1 = bitcast i32 %reg603 to i32		; <i32> [#uses=1]
+	%reg603-idxcast1-offset = add i32 %reg603-idxcast1, 1073741823		; <i32> [#uses=1]
+	zext i32 %reg603-idxcast1-offset to i64		; <i64>:19 [#uses=1]
+	%reg319 = getelementptr i32* %heap, i64 %19		; <i32*> [#uses=1]
+	%reg320 = load i32* %reg319		; <i32> [#uses=1]
+	zext i32 1 to i64		; <i64>:20 [#uses=1]
+	%reg7641 = getelementptr i32* %heap, i64 %20		; <i32*> [#uses=1]
+	store i32 %reg320, i32* %reg7641
+	%reg613 = add i32 %reg605, -1		; <i32> [#uses=4]
+	zext i32 1 to i64		; <i64>:21 [#uses=1]
+	%reg765 = getelementptr i32* %heap, i64 %21		; <i32*> [#uses=1]
+	%reg323 = load i32* %reg765		; <i32> [#uses=2]
+	%cond766 = icmp sgt i32 2, %reg613		; <i1> [#uses=1]
+	br i1 %cond766, label %bb26, label %bb21
+
+bb21:		; preds = %bb25, %bb20
+	%reg614 = phi i32 [ %reg619, %bb25 ], [ 2, %bb20 ]		; <i32> [#uses=6]
+	%reg615 = phi i32 [ %reg617, %bb25 ], [ 1, %bb20 ]		; <i32> [#uses=2]
+	%cond767 = icmp sge i32 %reg614, %reg613		; <i1> [#uses=1]
+	br i1 %cond767, label %bb24, label %bb22
+
+bb22:		; preds = %bb21
+	%reg614-idxcast = bitcast i32 %reg614 to i32		; <i32> [#uses=1]
+	%reg614-idxcast-offset = add i32 %reg614-idxcast, 1		; <i32> [#uses=1]
+	zext i32 %reg614-idxcast-offset to i64		; <i64>:22 [#uses=1]
+	%reg338 = getelementptr i32* %heap, i64 %22		; <i32*> [#uses=1]
+	%reg339 = load i32* %reg338		; <i32> [#uses=1]
+	%reg339-idxcast = bitcast i32 %reg339 to i32		; <i32> [#uses=1]
+	zext i32 %reg339-idxcast to i64		; <i64>:23 [#uses=1]
+	%reg346 = getelementptr i32* %weight, i64 %23		; <i32*> [#uses=1]
+	%reg614-idxcast1 = bitcast i32 %reg614 to i32		; <i32> [#uses=1]
+	zext i32 %reg614-idxcast1 to i64		; <i64>:24 [#uses=1]
+	%reg353 = getelementptr i32* %heap, i64 %24		; <i32*> [#uses=1]
+	%reg354 = load i32* %reg353		; <i32> [#uses=1]
+	%reg354-idxcast = bitcast i32 %reg354 to i32		; <i32> [#uses=1]
+	zext i32 %reg354-idxcast to i64		; <i64>:25 [#uses=1]
+	%reg361 = getelementptr i32* %weight, i64 %25		; <i32*> [#uses=1]
+	%reg362 = load i32* %reg346		; <i32> [#uses=1]
+	%reg363 = load i32* %reg361		; <i32> [#uses=1]
+	%cond768 = icmp sge i32 %reg362, %reg363		; <i1> [#uses=1]
+	br i1 %cond768, label %bb24, label %bb23
+
+bb23:		; preds = %bb22
+	%reg616 = add i32 %reg614, 1		; <i32> [#uses=1]
 	br label %bb24
 
-bb24:					;[#uses=4]
-	%reg617 = phi int [ %reg616, %bb23 ], [ %reg614, %bb22 ], [ %reg614, %bb21 ]		; <int> [#uses=4]
-	%reg323-idxcast = cast int %reg323 to uint		; <uint> [#uses=1]
-	cast uint %reg323-idxcast to long		; <long>:26 [#uses=1]
-	%reg370 = getelementptr int* %weight, long %26		; <int*> [#uses=1]
-	%reg617-idxcast = cast int %reg617 to uint		; <uint> [#uses=1]
-	cast uint %reg617-idxcast to long		; <long>:27 [#uses=1]
-	%reg377 = getelementptr int* %heap, long %27		; <int*> [#uses=1]
-	%reg378 = load int* %reg377		; <int> [#uses=2]
-	%reg378-idxcast = cast int %reg378 to uint		; <uint> [#uses=1]
-	cast uint %reg378-idxcast to long		; <long>:28 [#uses=1]
-	%reg385 = getelementptr int* %weight, long %28		; <int*> [#uses=1]
-	%reg386 = load int* %reg370		; <int> [#uses=1]
-	%reg387 = load int* %reg385		; <int> [#uses=1]
-	%cond769 = setlt int %reg386, %reg387		; <bool> [#uses=1]
-	br bool %cond769, label %bb26, label %bb25
-
-bb25:					;[#uses=4]
-	%reg615-idxcast = cast int %reg615 to uint		; <uint> [#uses=1]
-	cast uint %reg615-idxcast to long		; <long>:29 [#uses=1]
-	%reg394 = getelementptr int* %heap, long %29		; <int*> [#uses=1]
-	store int %reg378, int* %reg394
-	%reg619 = shl int %reg617, ubyte 1		; <int> [#uses=2]
-	%cond770 = setle int %reg619, %reg613		; <bool> [#uses=1]
-	br bool %cond770, label %bb21, label %bb26
-
-bb26:					;[#uses=4]
-	%reg620 = phi int [ %reg617, %bb25 ], [ %reg615, %bb24 ], [ 1, %bb20 ]		; <int> [#uses=1]
-	%reg620-idxcast = cast int %reg620 to uint		; <uint> [#uses=1]
-	cast uint %reg620-idxcast to long		; <long>:30 [#uses=1]
-	%reg409 = getelementptr int* %heap, long %30		; <int*> [#uses=1]
-	store int %reg323, int* %reg409
-	%reg621 = add uint %reg604, 1		; <uint> [#uses=5]
-	%reg113-idxcast = cast int %reg113 to uint		; <uint> [#uses=1]
-	cast uint %reg113-idxcast to long		; <long>:31 [#uses=1]
-	%reg416 = getelementptr int* %parent, long %31		; <int*> [#uses=1]
-	%reg114-idxcast = cast int %reg114 to uint		; <uint> [#uses=1]
-	cast uint %reg114-idxcast to long		; <long>:32 [#uses=1]
-	%reg423 = getelementptr int* %parent, long %32		; <int*> [#uses=1]
-	%cast889 = cast uint %reg621 to int		; <int> [#uses=1]
-	store int %cast889, int* %reg423
-	%cast890 = cast uint %reg621 to int		; <int> [#uses=1]
-	store int %cast890, int* %reg416
-	%reg604-offset = add uint %reg604, 1		; <uint> [#uses=1]
-	cast uint %reg604-offset to long		; <long>:33 [#uses=1]
-	%reg431 = getelementptr int* %weight, long %33		; <int*> [#uses=1]
-	%reg113-idxcast2 = cast int %reg113 to uint		; <uint> [#uses=1]
-	cast uint %reg113-idxcast2 to long		; <long>:34 [#uses=1]
-	%reg4381 = getelementptr int* %weight, long %34		; <int*> [#uses=1]
-	%reg439 = load int* %reg4381		; <int> [#uses=2]
-	%reg440 = and int %reg439, -256		; <int> [#uses=1]
-	%reg114-idxcast2 = cast int %reg114 to uint		; <uint> [#uses=1]
-	cast uint %reg114-idxcast2 to long		; <long>:35 [#uses=1]
-	%reg4471 = getelementptr int* %weight, long %35		; <int*> [#uses=1]
-	%reg448 = load int* %reg4471		; <int> [#uses=2]
-	%reg449 = and int %reg448, -256		; <int> [#uses=1]
-	%reg450 = add int %reg440, %reg449		; <int> [#uses=1]
-	%reg460 = and int %reg439, 255		; <int> [#uses=2]
-	%reg451 = and int %reg448, 255		; <int> [#uses=2]
-	%cond771 = setge int %reg451, %reg460		; <bool> [#uses=1]
-	br bool %cond771, label %bb28, label %bb27
-
-bb27:					;[#uses=2]
+bb24:		; preds = %bb23, %bb22, %bb21
+	%reg617 = phi i32 [ %reg616, %bb23 ], [ %reg614, %bb22 ], [ %reg614, %bb21 ]		; <i32> [#uses=4]
+	%reg323-idxcast = bitcast i32 %reg323 to i32		; <i32> [#uses=1]
+	zext i32 %reg323-idxcast to i64		; <i64>:26 [#uses=1]
+	%reg370 = getelementptr i32* %weight, i64 %26		; <i32*> [#uses=1]
+	%reg617-idxcast = bitcast i32 %reg617 to i32		; <i32> [#uses=1]
+	zext i32 %reg617-idxcast to i64		; <i64>:27 [#uses=1]
+	%reg377 = getelementptr i32* %heap, i64 %27		; <i32*> [#uses=1]
+	%reg378 = load i32* %reg377		; <i32> [#uses=2]
+	%reg378-idxcast = bitcast i32 %reg378 to i32		; <i32> [#uses=1]
+	zext i32 %reg378-idxcast to i64		; <i64>:28 [#uses=1]
+	%reg385 = getelementptr i32* %weight, i64 %28		; <i32*> [#uses=1]
+	%reg386 = load i32* %reg370		; <i32> [#uses=1]
+	%reg387 = load i32* %reg385		; <i32> [#uses=1]
+	%cond769 = icmp slt i32 %reg386, %reg387		; <i1> [#uses=1]
+	br i1 %cond769, label %bb26, label %bb25
+
+bb25:		; preds = %bb24
+	%reg615-idxcast = bitcast i32 %reg615 to i32		; <i32> [#uses=1]
+	zext i32 %reg615-idxcast to i64		; <i64>:29 [#uses=1]
+	%reg394 = getelementptr i32* %heap, i64 %29		; <i32*> [#uses=1]
+	store i32 %reg378, i32* %reg394
+	%reg619 = shl i32 %reg617, 1		; <i32> [#uses=2]
+	%cond770 = icmp sle i32 %reg619, %reg613		; <i1> [#uses=1]
+	br i1 %cond770, label %bb21, label %bb26
+
+bb26:		; preds = %bb25, %bb24, %bb20
+	%reg620 = phi i32 [ %reg617, %bb25 ], [ %reg615, %bb24 ], [ 1, %bb20 ]		; <i32> [#uses=1]
+	%reg620-idxcast = bitcast i32 %reg620 to i32		; <i32> [#uses=1]
+	zext i32 %reg620-idxcast to i64		; <i64>:30 [#uses=1]
+	%reg409 = getelementptr i32* %heap, i64 %30		; <i32*> [#uses=1]
+	store i32 %reg323, i32* %reg409
+	%reg621 = add i32 %reg604, 1		; <i32> [#uses=5]
+	%reg113-idxcast = bitcast i32 %reg113 to i32		; <i32> [#uses=1]
+	zext i32 %reg113-idxcast to i64		; <i64>:31 [#uses=1]
+	%reg416 = getelementptr i32* %parent, i64 %31		; <i32*> [#uses=1]
+	%reg114-idxcast = bitcast i32 %reg114 to i32		; <i32> [#uses=1]
+	zext i32 %reg114-idxcast to i64		; <i64>:32 [#uses=1]
+	%reg423 = getelementptr i32* %parent, i64 %32		; <i32*> [#uses=1]
+	%cast889 = bitcast i32 %reg621 to i32		; <i32> [#uses=1]
+	store i32 %cast889, i32* %reg423
+	%cast890 = bitcast i32 %reg621 to i32		; <i32> [#uses=1]
+	store i32 %cast890, i32* %reg416
+	%reg604-offset = add i32 %reg604, 1		; <i32> [#uses=1]
+	zext i32 %reg604-offset to i64		; <i64>:33 [#uses=1]
+	%reg431 = getelementptr i32* %weight, i64 %33		; <i32*> [#uses=1]
+	%reg113-idxcast2 = bitcast i32 %reg113 to i32		; <i32> [#uses=1]
+	zext i32 %reg113-idxcast2 to i64		; <i64>:34 [#uses=1]
+	%reg4381 = getelementptr i32* %weight, i64 %34		; <i32*> [#uses=1]
+	%reg439 = load i32* %reg4381		; <i32> [#uses=2]
+	%reg440 = and i32 %reg439, -256		; <i32> [#uses=1]
+	%reg114-idxcast2 = bitcast i32 %reg114 to i32		; <i32> [#uses=1]
+	zext i32 %reg114-idxcast2 to i64		; <i64>:35 [#uses=1]
+	%reg4471 = getelementptr i32* %weight, i64 %35		; <i32*> [#uses=1]
+	%reg448 = load i32* %reg4471		; <i32> [#uses=2]
+	%reg449 = and i32 %reg448, -256		; <i32> [#uses=1]
+	%reg450 = add i32 %reg440, %reg449		; <i32> [#uses=1]
+	%reg460 = and i32 %reg439, 255		; <i32> [#uses=2]
+	%reg451 = and i32 %reg448, 255		; <i32> [#uses=2]
+	%cond771 = icmp sge i32 %reg451, %reg460		; <i1> [#uses=1]
+	br i1 %cond771, label %bb28, label %bb27
+
+bb27:		; preds = %bb26
 	br label %bb28
 
-bb28:					;[#uses=3]
-	%reg623 = phi int [ %reg460, %bb27 ], [ %reg451, %bb26 ]		; <int> [#uses=1]
-	%reg469 = add int %reg623, 1		; <int> [#uses=1]
-	%reg470 = or int %reg450, %reg469		; <int> [#uses=1]
-	store int %reg470, int* %reg431
-	%reg604-offset1 = add uint %reg604, 1		; <uint> [#uses=1]
-	cast uint %reg604-offset1 to long		; <long>:36 [#uses=1]
-	%reg4771 = getelementptr int* %parent, long %36		; <int*> [#uses=1]
-	store int -1, int* %reg4771
-	%reg624 = add int %reg613, 1		; <int> [#uses=2]
-	%reg603-idxcast2 = cast int %reg603 to uint		; <uint> [#uses=1]
-	%reg603-idxcast2-offset = add uint %reg603-idxcast2, 1073741823		; <uint> [#uses=1]
-	cast uint %reg603-idxcast2-offset to long		; <long>:37 [#uses=1]
-	%reg485 = getelementptr int* %heap, long %37		; <int*> [#uses=1]
-	%cast902 = cast uint %reg621 to int		; <int> [#uses=1]
-	store int %cast902, int* %reg485
+bb28:		; preds = %bb27, %bb26
+	%reg623 = phi i32 [ %reg460, %bb27 ], [ %reg451, %bb26 ]		; <i32> [#uses=1]
+	%reg469 = add i32 %reg623, 1		; <i32> [#uses=1]
+	%reg470 = or i32 %reg450, %reg469		; <i32> [#uses=1]
+	store i32 %reg470, i32* %reg431
+	%reg604-offset1 = add i32 %reg604, 1		; <i32> [#uses=1]
+	zext i32 %reg604-offset1 to i64		; <i64>:36 [#uses=1]
+	%reg4771 = getelementptr i32* %parent, i64 %36		; <i32*> [#uses=1]
+	store i32 -1, i32* %reg4771
+	%reg624 = add i32 %reg613, 1		; <i32> [#uses=2]
+	%reg603-idxcast2 = bitcast i32 %reg603 to i32		; <i32> [#uses=1]
+	%reg603-idxcast2-offset = add i32 %reg603-idxcast2, 1073741823		; <i32> [#uses=1]
+	zext i32 %reg603-idxcast2-offset to i64		; <i64>:37 [#uses=1]
+	%reg485 = getelementptr i32* %heap, i64 %37		; <i32*> [#uses=1]
+	%cast902 = bitcast i32 %reg621 to i32		; <i32> [#uses=1]
+	store i32 %cast902, i32* %reg485
 	br label %bb30
 
-bb29:					;[#uses=2]
-	%reg625-idxcast = cast int %reg625 to uint		; <uint> [#uses=1]
-	cast uint %reg625-idxcast to long		; <long>:38 [#uses=1]
-	%reg526 = getelementptr int* %heap, long %38		; <int*> [#uses=1]
-	store int %reg510, int* %reg526
+bb29:		; preds = %bb30
+	%reg625-idxcast = bitcast i32 %reg625 to i32		; <i32> [#uses=1]
+	zext i32 %reg625-idxcast to i64		; <i64>:38 [#uses=1]
+	%reg526 = getelementptr i32* %heap, i64 %38		; <i32*> [#uses=1]
+	store i32 %reg510, i32* %reg526
 	br label %bb30
 
-bb30:					;[#uses=2]
-	%reg625 = phi int [ %reg502, %bb29 ], [ %reg624, %bb28 ]		; <int> [#uses=3]
-	%reg604-offset2 = add uint %reg604, 1		; <uint> [#uses=1]
-	cast uint %reg604-offset2 to long		; <long>:39 [#uses=1]
-	%reg501 = getelementptr int* %weight, long %39		; <int*> [#uses=1]
-	%reg502 = shr int %reg625, ubyte 1		; <int> [#uses=2]
-	%reg502-idxcast = cast int %reg502 to uint		; <uint> [#uses=1]
-	cast uint %reg502-idxcast to long		; <long>:40 [#uses=1]
-	%reg509 = getelementptr int* %heap, long %40		; <int*> [#uses=1]
-	%reg510 = load int* %reg509		; <int> [#uses=2]
-	%reg510-idxcast = cast int %reg510 to uint		; <uint> [#uses=1]
-	cast uint %reg510-idxcast to long		; <long>:41 [#uses=1]
-	%reg517 = getelementptr int* %weight, long %41		; <int*> [#uses=1]
-	%reg518 = load int* %reg501		; <int> [#uses=1]
-	%reg519 = load int* %reg517		; <int> [#uses=1]
-	%cond772 = setlt int %reg518, %reg519		; <bool> [#uses=1]
-	br bool %cond772, label %bb29, label %bb31
-
-bb31:					;[#uses=3]
-	%reg625-idxcast1 = cast int %reg625 to uint		; <uint> [#uses=1]
-	cast uint %reg625-idxcast1 to long		; <long>:42 [#uses=1]
-	%reg542 = getelementptr int* %heap, long %42		; <int*> [#uses=1]
-	%cast916 = cast uint %reg621 to int		; <int> [#uses=1]
-	store int %cast916, int* %reg542
-	%cond773 = setgt int %reg624, 1		; <bool> [#uses=1]
-	br bool %cond773, label %bb14, label %bb32
-
-bb32:					;[#uses=2]
-	%reg627 = phi uint [ %reg621, %bb31 ], [ %cast918, %bb13 ]		; <uint> [#uses=1]
-	%cast919 = cast uint %reg627 to int		; <int> [#uses=1]
-	%cond774 = setle int %cast919, 515		; <bool> [#uses=1]
-	br bool %cond774, label %bb34, label %bb33
-
-bb33:					;[#uses=1]
-	cast uint 0 to long		; <long>:43 [#uses=1]
-	cast uint 0 to long		; <long>:44 [#uses=1]
-	%cast785 = getelementptr [21 x sbyte]* %.LC1, long %43, long %44		; <sbyte*> [#uses=1]
-	call void %panic( sbyte* %cast785 )
+bb30:		; preds = %bb29, %bb28
+	%reg625 = phi i32 [ %reg502, %bb29 ], [ %reg624, %bb28 ]		; <i32> [#uses=3]
+	%reg604-offset2 = add i32 %reg604, 1		; <i32> [#uses=1]
+	zext i32 %reg604-offset2 to i64		; <i64>:39 [#uses=1]
+	%reg501 = getelementptr i32* %weight, i64 %39		; <i32*> [#uses=1]
+	%reg502 = ashr i32 %reg625, 1		; <i32> [#uses=2]
+	%reg502-idxcast = bitcast i32 %reg502 to i32		; <i32> [#uses=1]
+	zext i32 %reg502-idxcast to i64		; <i64>:40 [#uses=1]
+	%reg509 = getelementptr i32* %heap, i64 %40		; <i32*> [#uses=1]
+	%reg510 = load i32* %reg509		; <i32> [#uses=2]
+	%reg510-idxcast = bitcast i32 %reg510 to i32		; <i32> [#uses=1]
+	zext i32 %reg510-idxcast to i64		; <i64>:41 [#uses=1]
+	%reg517 = getelementptr i32* %weight, i64 %41		; <i32*> [#uses=1]
+	%reg518 = load i32* %reg501		; <i32> [#uses=1]
+	%reg519 = load i32* %reg517		; <i32> [#uses=1]
+	%cond772 = icmp slt i32 %reg518, %reg519		; <i1> [#uses=1]
+	br i1 %cond772, label %bb29, label %bb31
+
+bb31:		; preds = %bb30
+	%reg625-idxcast1 = bitcast i32 %reg625 to i32		; <i32> [#uses=1]
+	zext i32 %reg625-idxcast1 to i64		; <i64>:42 [#uses=1]
+	%reg542 = getelementptr i32* %heap, i64 %42		; <i32*> [#uses=1]
+	%cast916 = bitcast i32 %reg621 to i32		; <i32> [#uses=1]
+	store i32 %cast916, i32* %reg542
+	%cond773 = icmp sgt i32 %reg624, 1		; <i1> [#uses=1]
+	br i1 %cond773, label %bb14, label %bb32
+
+bb32:		; preds = %bb31, %bb13
+	%reg627 = phi i32 [ %reg621, %bb31 ], [ %cast918, %bb13 ]		; <i32> [#uses=1]
+	%cast919 = bitcast i32 %reg627 to i32		; <i32> [#uses=1]
+	%cond774 = icmp sle i32 %cast919, 515		; <i1> [#uses=1]
+	br i1 %cond774, label %bb34, label %bb33
+
+bb33:		; preds = %bb32
+	zext i32 0 to i64		; <i64>:43 [#uses=1]
+	zext i32 0 to i64		; <i64>:44 [#uses=1]
+	%cast785 = getelementptr [21 x i8]* @.LC1, i64 %43, i64 %44		; <i8*> [#uses=1]
+	call void @panic( i8* %cast785 )
 	br label %bb34
 
-bb34:					;[#uses=5]
-	%cond775 = setgt int 1, %reg109		; <bool> [#uses=1]
-	br bool %cond775, label %bb40, label %bb35
-
-bb35:					;[#uses=5]
-	%reg629 = phi ubyte [ %reg639, %bb39 ], [ 0, %bb34 ]		; <ubyte> [#uses=1]
-	%cann-indvar = phi uint [ 0, %bb34 ], [ %add1-indvar, %bb39 ]		; <uint> [#uses=4]
-	%cann-indvar-casted = cast uint %cann-indvar to int		; <int> [#uses=1]
-	%reg630 = add int %cann-indvar-casted, 1		; <int> [#uses=2]
-	%add1-indvar = add uint %cann-indvar, 1		; <uint> [#uses=1]
-	%cann-indvar-offset1 = add uint %cann-indvar, 1		; <uint> [#uses=1]
-	cast uint %cann-indvar-offset1 to long		; <long>:45 [#uses=1]
-	%reg589 = getelementptr int* %parent, long %45		; <int*> [#uses=1]
-	%reg590 = load int* %reg589		; <int> [#uses=1]
-	%cond776 = setlt int %reg590, 0		; <bool> [#uses=1]
-	%parent-idxcast = cast int* %parent to uint		; <uint> [#uses=1]
-	%cast948 = cast int %reg630 to uint		; <uint> [#uses=1]
-	br bool %cond776, label %bb37, label %bb36
-
-bb36:					;[#uses=5]
-	%reg632 = phi uint [ %reg634, %bb36 ], [ %cast948, %bb35 ]		; <uint> [#uses=1]
-	%reg633 = phi uint [ %reg635, %bb36 ], [ 0, %bb35 ]		; <uint> [#uses=3]
-	%reg633-casted = cast uint %reg633 to sbyte*		; <sbyte*> [#uses=0]
-	%reg631-scale = mul uint %reg633, 0		; <uint> [#uses=1]
-	%reg631-scale = cast uint %reg631-scale to sbyte*		; <sbyte*> [#uses=1]
-	cast uint %parent-idxcast to long		; <long>:46 [#uses=1]
-	%reg6311 = getelementptr sbyte* %reg631-scale, long %46		; <sbyte*> [#uses=2]
-	%reg632-scale = mul uint %reg632, 4		; <uint> [#uses=1]
-	cast uint %reg632-scale to long		; <long>:47 [#uses=1]
-	%reg5581 = getelementptr sbyte* %reg6311, long %47		; <sbyte*> [#uses=1]
-	%cast924 = cast sbyte* %reg5581 to uint*		; <uint*> [#uses=1]
-	%reg634 = load uint* %cast924		; <uint> [#uses=2]
-	%reg635 = add uint %reg633, 1		; <uint> [#uses=2]
-	%reg634-scale = mul uint %reg634, 4		; <uint> [#uses=1]
-	cast uint %reg634-scale to long		; <long>:48 [#uses=1]
-	%reg5501 = getelementptr sbyte* %reg6311, long %48		; <sbyte*> [#uses=1]
-	%cast925 = cast sbyte* %reg5501 to int*		; <int*> [#uses=1]
-	%reg551 = load int* %cast925		; <int> [#uses=1]
-	%cond777 = setge int %reg551, 0		; <bool> [#uses=1]
-	br bool %cond777, label %bb36, label %bb37
-
-bb37:					;[#uses=3]
-	%reg637 = phi uint [ %reg635, %bb36 ], [ 0, %bb35 ]		; <uint> [#uses=2]
-	%cast928 = cast uint %reg637 to int		; <int> [#uses=1]
-	%cann-indvar-offset = add uint %cann-indvar, 1		; <uint> [#uses=1]
-	cast uint %cann-indvar-offset to long		; <long>:49 [#uses=1]
-	%reg561 = getelementptr ubyte* %reg107, long %49		; <ubyte*> [#uses=1]
-	cast uint 4294967295 to long		; <long>:50 [#uses=1]
-	%reg778 = getelementptr ubyte* %reg561, long %50		; <ubyte*> [#uses=1]
-	%cast788 = cast uint %reg637 to ubyte		; <ubyte> [#uses=1]
-	store ubyte %cast788, ubyte* %reg778
-	%cond779 = setle int %cast928, %reg110		; <bool> [#uses=1]
-	br bool %cond779, label %bb39, label %bb38
-
-bb38:					;[#uses=2]
+bb34:		; preds = %bb33, %bb32
+	%cond775 = icmp sgt i32 1, %reg109		; <i1> [#uses=1]
+	br i1 %cond775, label %bb40, label %bb35
+
+bb35:		; preds = %bb39, %bb34
+	%reg629 = phi i8 [ %reg639, %bb39 ], [ 0, %bb34 ]		; <i8> [#uses=1]
+	%cann-indvar = phi i32 [ 0, %bb34 ], [ %add1-indvar, %bb39 ]		; <i32> [#uses=4]
+	%cann-indvar-casted = bitcast i32 %cann-indvar to i32		; <i32> [#uses=1]
+	%reg630 = add i32 %cann-indvar-casted, 1		; <i32> [#uses=2]
+	%add1-indvar = add i32 %cann-indvar, 1		; <i32> [#uses=1]
+	%cann-indvar-offset1 = add i32 %cann-indvar, 1		; <i32> [#uses=1]
+	zext i32 %cann-indvar-offset1 to i64		; <i64>:45 [#uses=1]
+	%reg589 = getelementptr i32* %parent, i64 %45		; <i32*> [#uses=1]
+	%reg590 = load i32* %reg589		; <i32> [#uses=1]
+	%cond776 = icmp slt i32 %reg590, 0		; <i1> [#uses=1]
+	%parent-idxcast = ptrtoint i32* %parent to i32		; <i32> [#uses=1]
+	%cast948 = bitcast i32 %reg630 to i32		; <i32> [#uses=1]
+	br i1 %cond776, label %bb37, label %bb36
+
+bb36:		; preds = %bb36, %bb35
+	%reg632 = phi i32 [ %reg634, %bb36 ], [ %cast948, %bb35 ]		; <i32> [#uses=1]
+	%reg633 = phi i32 [ %reg635, %bb36 ], [ 0, %bb35 ]		; <i32> [#uses=3]
+	%reg633-casted = inttoptr i32 %reg633 to i8*		; <i8*> [#uses=0]
+	%reg631-scale = mul i32 %reg633, 0		; <i32> [#uses=1]
+	%reg631-scale.upgrd.10 = inttoptr i32 %reg631-scale to i8*		; <i8*> [#uses=1]
+	zext i32 %parent-idxcast to i64		; <i64>:46 [#uses=1]
+	%reg6311 = getelementptr i8* %reg631-scale.upgrd.10, i64 %46		; <i8*> [#uses=2]
+	%reg632-scale = mul i32 %reg632, 4		; <i32> [#uses=1]
+	zext i32 %reg632-scale to i64		; <i64>:47 [#uses=1]
+	%reg5581 = getelementptr i8* %reg6311, i64 %47		; <i8*> [#uses=1]
+	%cast924 = bitcast i8* %reg5581 to i32*		; <i32*> [#uses=1]
+	%reg634 = load i32* %cast924		; <i32> [#uses=2]
+	%reg635 = add i32 %reg633, 1		; <i32> [#uses=2]
+	%reg634-scale = mul i32 %reg634, 4		; <i32> [#uses=1]
+	zext i32 %reg634-scale to i64		; <i64>:48 [#uses=1]
+	%reg5501 = getelementptr i8* %reg6311, i64 %48		; <i8*> [#uses=1]
+	%cast925 = bitcast i8* %reg5501 to i32*		; <i32*> [#uses=1]
+	%reg551 = load i32* %cast925		; <i32> [#uses=1]
+	%cond777 = icmp sge i32 %reg551, 0		; <i1> [#uses=1]
+	br i1 %cond777, label %bb36, label %bb37
+
+bb37:		; preds = %bb36, %bb35
+	%reg637 = phi i32 [ %reg635, %bb36 ], [ 0, %bb35 ]		; <i32> [#uses=2]
+	%cast928 = bitcast i32 %reg637 to i32		; <i32> [#uses=1]
+	%cann-indvar-offset = add i32 %cann-indvar, 1		; <i32> [#uses=1]
+	zext i32 %cann-indvar-offset to i64		; <i64>:49 [#uses=1]
+	%reg561 = getelementptr i8* %reg107, i64 %49		; <i8*> [#uses=1]
+	zext i32 -1 to i64		; <i64>:50 [#uses=1]
+	%reg778 = getelementptr i8* %reg561, i64 %50		; <i8*> [#uses=1]
+	%cast788 = trunc i32 %reg637 to i8		; <i8> [#uses=1]
+	store i8 %cast788, i8* %reg778
+	%cond779 = icmp sle i32 %cast928, %reg110		; <i1> [#uses=1]
+	br i1 %cond779, label %bb39, label %bb38
+
+bb38:		; preds = %bb37
 	br label %bb39
 
-bb39:					;[#uses=5]
-	%reg639 = phi ubyte [ 1, %bb38 ], [ %reg629, %bb37 ]		; <ubyte> [#uses=2]
-	%reg640 = add int %reg630, 1		; <int> [#uses=1]
-	%cond780 = setle int %reg640, %reg109		; <bool> [#uses=1]
-	br bool %cond780, label %bb35, label %bb40
-
-bb40:					;[#uses=2]
-	%reg641 = phi ubyte [ %reg639, %bb39 ], [ 0, %bb34 ]		; <ubyte> [#uses=1]
-	%cond781 = seteq ubyte %reg641, 0		; <bool> [#uses=1]
-	br bool %cond781, label %bb44, label %bb41
-
-bb41:					;[#uses=2]
-	%cond782 = setge int 1, %reg109		; <bool> [#uses=1]
-	br bool %cond782, label %bb6, label %bb42
-
-bb42:					;[#uses=3]
-	%cann-indvar2 = phi int [ 0, %bb41 ], [ %add1-indvar2, %bb42 ]		; <int> [#uses=3]
-	%reg643 = add int %cann-indvar2, 1		; <int> [#uses=1]
-	%add1-indvar2 = add int %cann-indvar2, 1		; <int> [#uses=1]
-	%cann-indvar2-idxcast = cast int %cann-indvar2 to uint		; <uint> [#uses=1]
-	%cann-indvar2-idxcast-offset = add uint %cann-indvar2-idxcast, 1		; <uint> [#uses=1]
-	cast uint %cann-indvar2-idxcast-offset to long		; <long>:51 [#uses=1]
-	%reg569 = getelementptr int* %weight, long %51		; <int*> [#uses=2]
-	%reg570 = load int* %reg569		; <int> [#uses=2]
-	%reg644 = shr int %reg570, ubyte 8		; <int> [#uses=1]
-	%reg572 = shr int %reg570, ubyte 31		; <int> [#uses=1]
-	%cast933 = cast int %reg572 to uint		; <uint> [#uses=1]
-	%reg573 = shr uint %cast933, ubyte 31		; <uint> [#uses=1]
-	%cast934 = cast uint %reg573 to int		; <int> [#uses=1]
-	%reg574 = add int %reg644, %cast934		; <int> [#uses=1]
-	%reg571 = shr int %reg574, ubyte 1		; <int> [#uses=1]
-	%reg645 = add int %reg571, 1		; <int> [#uses=1]
-	%reg582 = shl int %reg645, ubyte 8		; <int> [#uses=1]
-	store int %reg582, int* %reg569
-	%reg646 = add int %reg643, 1		; <int> [#uses=1]
-	%cond783 = setlt int %reg646, %reg109		; <bool> [#uses=1]
-	br bool %cond783, label %bb42, label %bb43
-
-bb43:					;[#uses=1]
+bb39:		; preds = %bb38, %bb37
+	%reg639 = phi i8 [ 1, %bb38 ], [ %reg629, %bb37 ]		; <i8> [#uses=2]
+	%reg640 = add i32 %reg630, 1		; <i32> [#uses=1]
+	%cond780 = icmp sle i32 %reg640, %reg109		; <i1> [#uses=1]
+	br i1 %cond780, label %bb35, label %bb40
+
+bb40:		; preds = %bb39, %bb34
+	%reg641 = phi i8 [ %reg639, %bb39 ], [ 0, %bb34 ]		; <i8> [#uses=1]
+	%cond781 = icmp eq i8 %reg641, 0		; <i1> [#uses=1]
+	br i1 %cond781, label %bb44, label %bb41
+
+bb41:		; preds = %bb40
+	%cond782 = icmp sge i32 1, %reg109		; <i1> [#uses=1]
+	br i1 %cond782, label %bb6, label %bb42
+
+bb42:		; preds = %bb42, %bb41
+	%cann-indvar2 = phi i32 [ 0, %bb41 ], [ %add1-indvar2, %bb42 ]		; <i32> [#uses=3]
+	%reg643 = add i32 %cann-indvar2, 1		; <i32> [#uses=1]
+	%add1-indvar2 = add i32 %cann-indvar2, 1		; <i32> [#uses=1]
+	%cann-indvar2-idxcast = bitcast i32 %cann-indvar2 to i32		; <i32> [#uses=1]
+	%cann-indvar2-idxcast-offset = add i32 %cann-indvar2-idxcast, 1		; <i32> [#uses=1]
+	zext i32 %cann-indvar2-idxcast-offset to i64		; <i64>:51 [#uses=1]
+	%reg569 = getelementptr i32* %weight, i64 %51		; <i32*> [#uses=2]
+	%reg570 = load i32* %reg569		; <i32> [#uses=2]
+	%reg644 = ashr i32 %reg570, 8		; <i32> [#uses=1]
+	%reg572 = ashr i32 %reg570, 31		; <i32> [#uses=1]
+	%cast933 = bitcast i32 %reg572 to i32		; <i32> [#uses=1]
+	%reg573 = lshr i32 %cast933, 31		; <i32> [#uses=1]
+	%cast934 = bitcast i32 %reg573 to i32		; <i32> [#uses=1]
+	%reg574 = add i32 %reg644, %cast934		; <i32> [#uses=1]
+	%reg571 = ashr i32 %reg574, 1		; <i32> [#uses=1]
+	%reg645 = add i32 %reg571, 1		; <i32> [#uses=1]
+	%reg582 = shl i32 %reg645, 8		; <i32> [#uses=1]
+	store i32 %reg582, i32* %reg569
+	%reg646 = add i32 %reg643, 1		; <i32> [#uses=1]
+	%cond783 = icmp slt i32 %reg646, %reg109		; <i1> [#uses=1]
+	br i1 %cond783, label %bb42, label %bb43
+
+bb43:		; preds = %bb42
 	br label %bb6
 
-bb44:					;[#uses=1]
+bb44:		; preds = %bb40
 	ret void
 }
 
-declare void %panic(sbyte*)
+declare void @panic(i8*)
diff --git a/test/Transforms/InstCombine/2002-08-02-CastTest.ll b/test/Transforms/InstCombine/2002-08-02-CastTest.ll
index 23284a6312..54c836c105 100644
--- a/test/Transforms/InstCombine/2002-08-02-CastTest.ll
+++ b/test/Transforms/InstCombine/2002-08-02-CastTest.ll
@@ -1,11 +1,11 @@
 ; This testcase is incorrectly getting completely eliminated.  There should be
 ; SOME instruction named %c here, even if it's a bitwise and.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep %c
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep %c
 ;
-ulong %test3(ulong %A) {
-        %c1 = cast ulong %A to ubyte
-        %c2 = cast ubyte %c1 to ulong
-        ret ulong %c2
+define i64 @test3(i64 %A) {
+        %c1 = trunc i64 %A to i8                ; <i8> [#uses=1]
+        %c2 = zext i8 %c1 to i64                ; <i64> [#uses=1]
+        ret i64 %c2
 }
 
diff --git a/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll b/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll
index 69bec19b2b..5b127d7b79 100644
--- a/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll
+++ b/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll
@@ -1,12 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
+; RUN: llvm-as < %s | opt -instcombine
 
-%bob = type { int }
+        %bob = type { i32 }
 
-int %alias() {
-    %pbob1 = alloca %bob
-    %pbob2 = getelementptr %bob* %pbob1
-    %pbobel = getelementptr %bob* %pbob2, long 0, uint 0
-    %rval = load int* %pbobel
-    ret int %rval
+define i32 @alias() {
+        %pbob1 = alloca %bob            ; <%bob*> [#uses=1]
+        %pbob2 = getelementptr %bob* %pbob1             ; <%bob*> [#uses=1]
+        %pbobel = getelementptr %bob* %pbob2, i64 0, i32 0              ; <i32*> [#uses=1]
+        %rval = load i32* %pbobel               ; <i32> [#uses=1]
+        ret i32 %rval
 }
 
diff --git a/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll b/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll
index 6233e5027b..e7bd6a8da2 100644
--- a/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll
+++ b/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll
@@ -1,10 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep add
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep add
 
-int %test(int %A) {
-  %A.neg = sub int 0, %A
-  %.neg = sub int 0, 1
-  %X = add int %.neg, 1
-  %Y.neg.ra = add int %A, %X
-  %r = add int %A.neg, %Y.neg.ra
-  ret int %r
+define i32 @test(i32 %A) {
+        %A.neg = sub i32 0, %A          ; <i32> [#uses=1]
+        %.neg = sub i32 0, 1            ; <i32> [#uses=1]
+        %X = add i32 %.neg, 1           ; <i32> [#uses=1]
+        %Y.neg.ra = add i32 %A, %X              ; <i32> [#uses=1]
+        %r = add i32 %A.neg, %Y.neg.ra          ; <i32> [#uses=1]
+        ret i32 %r
 }
+
diff --git a/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll b/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll
index 453258980d..e7e784882a 100644
--- a/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll
+++ b/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll
@@ -1,7 +1,8 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 4294967295
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep 4294967295
 
-ulong %test(ulong %Val) {
-        %tmp.3 = cast ulong %Val to uint              ; <uint> [#uses=1]
-        %tmp.8 = cast uint %tmp.3 to ulong              ; <ulong> [#uses=1]
-	ret ulong %tmp.8
+define i64 @test(i64 %Val) {
+        %tmp.3 = trunc i64 %Val to i32          ; <i32> [#uses=1]
+        %tmp.8 = zext i32 %tmp.3 to i64         ; <i64> [#uses=1]
+        ret i64 %tmp.8
 }
+
diff --git a/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll b/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll
index 6222169e08..214fa4d846 100644
--- a/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll
+++ b/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll
@@ -1,8 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-%X = global int 5
-long %test() {
-        %C = add long 1, 2
-	%V = add long cast(int* %X to long), %C
-	ret long %V
+@X = global i32 5               ; <i32*> [#uses=1]
+
+define i64 @test() {
+        %C = add i64 1, 2               ; <i64> [#uses=1]
+        %V = add i64 ptrtoint (i32* @X to i64), %C              ; <i64> [#uses=1]
+        ret i64 %V
 }
+
diff --git a/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll b/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll
index ae823d6bf6..724f30f488 100644
--- a/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll
+++ b/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll
@@ -2,13 +2,15 @@
 ; because it things that the constant value is a not expression... and 
 ; constantly inverts the branch back and forth.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-
-ubyte %test19(bool %c) {
-        br bool true, label %True, label %False
-True:
-        ret ubyte 1
-False:
-        ret ubyte 3
+; RUN: llvm-as < %s | opt -instcombine -disable-output
+
+define i8 @test19(i1 %c) {
+        br i1 true, label %True, label %False
+
+True:           ; preds = %0
+        ret i8 1
+
+False:          ; preds = %0
+        ret i8 3
 }
 
diff --git a/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll b/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll
index 92a32d5d35..d6cacece08 100644
--- a/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll
+++ b/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll
@@ -1,12 +1,13 @@
 ; This is a bug in the VMcode library, not instcombine, it's just convenient 
 ; to expose it here.
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-%A = global int 1
-%B = global int 2
+@A = global i32 1               ; <i32*> [#uses=1]
+@B = global i32 2               ; <i32*> [#uses=1]
 
-bool %test() {
-	%C = setlt int* getelementptr (int* %A, long 1), getelementptr (int* %B, long 2)    ; Will get promoted to constantexpr
-	ret bool %C
+define i1 @test() {
+        %C = icmp ult i32* getelementptr (i32* @A, i64 1), getelementptr (i32* @B, i64 2) ; <i1> [#uses=1]
+        ret i1 %C
 }
+
diff --git a/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll b/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll
index a3c30a8f72..14140018f9 100644
--- a/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll
+++ b/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll
@@ -10,38 +10,35 @@
 ;	should pass through the optimizer without failure.
 ;
 ; Extra code:
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
-; END.
+; RUN: llvm-as < %s | opt -instcombine
 ;
 
-target endian = little
-target pointersize = 32
-%silly = external constant int		; <int*> [#uses=1]
+target datalayout = "e-p:32:32"
+@silly = external constant i32          ; <i32*> [#uses=1]
 
-implementation   ; Functions:
+declare void @bzero(i8*, i32)
 
-declare void %bzero(sbyte*, uint)
+declare void @bcopy(i8*, i8*, i32)
 
-declare void %bcopy(sbyte*, sbyte*, uint)
+declare i32 @bcmp(i8*, i8*, i32)
 
-declare int %bcmp(sbyte*, sbyte*, uint)
+declare i32 @fputs(i8*, i8*)
 
-declare int %fputs(sbyte*, sbyte*)
+declare i32 @fputs_unlocked(i8*, i8*)
 
-declare int %fputs_unlocked(sbyte*, sbyte*)
+define i32 @function(i32 %a.1) {
+entry:
+        %a.0 = alloca i32               ; <i32*> [#uses=2]
+        %result = alloca i32            ; <i32*> [#uses=2]
+        store i32 %a.1, i32* %a.0
+        %tmp.0 = load i32* %a.0         ; <i32> [#uses=1]
+        %tmp.1 = load i32* @silly               ; <i32> [#uses=1]
+        %tmp.2 = add i32 %tmp.0, %tmp.1         ; <i32> [#uses=1]
+        store i32 %tmp.2, i32* %result
+        br label %return
 
-int %function(int %a.1) {
-entry:		; No predecessors!
-	%a.0 = alloca int		; <int*> [#uses=2]
-	%result = alloca int		; <int*> [#uses=2]
-	store int %a.1, int* %a.0
-	%tmp.0 = load int* %a.0		; <int> [#uses=1]
-	%tmp.1 = load int* %silly		; <int> [#uses=1]
-	%tmp.2 = add int %tmp.0, %tmp.1		; <int> [#uses=1]
-	store int %tmp.2, int* %result
-	br label %return
-
-return:		; preds = %entry
-	%tmp.3 = load int* %result		; <int> [#uses=1]
-	ret int %tmp.3
+return:         ; preds = %entry
+        %tmp.3 = load i32* %result              ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
+
diff --git a/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll b/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll
index 81594dbb6b..209ab1b336 100644
--- a/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll
+++ b/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll
@@ -1,23 +1,21 @@
 ; This testcase can be simplified by "realizing" that alloca can never return 
 ; null.
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -simplifycfg | \
+; RUN: llvm-as < %s | opt -instcombine -simplifycfg | \
 ; RUN:    llvm-dis | not grep br
 
-implementation   ; Functions:
+declare i32 @bitmap_clear(...)
 
-declare int %bitmap_clear(...)
-
-int %oof() {
+define i32 @oof() {
 entry:
-        %live_head = alloca int         ; <int*> [#uses=2]
-        %tmp.1 = setne int* %live_head, null            ; <bool> [#uses=1]
-        br bool %tmp.1, label %then, label %UnifiedExitNode
+        %live_head = alloca i32         ; <i32*> [#uses=2]
+        %tmp.1 = icmp ne i32* %live_head, null          ; <i1> [#uses=1]
+        br i1 %tmp.1, label %then, label %UnifiedExitNode
 
-then:
-        %tmp.4 = call int (...)* %bitmap_clear( int* %live_head )              ; <int> [#uses=0]
+then:           ; preds = %entry
+        %tmp.4 = call i32 (...)* @bitmap_clear( i32* %live_head )               ; <i32> [#uses=0]
         br label %UnifiedExitNode
 
-UnifiedExitNode:
-        ret int 0
+UnifiedExitNode:                ; preds = %then, %entry
+        ret i32 0
 }
 
diff --git a/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll b/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll
index adb1474a98..9779f21f92 100644
--- a/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll
+++ b/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll
@@ -1,5 +1,7 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep load
-void %test(int* %P) {
-	%X = volatile load int* %P  ; Dead but not deletable!
-	ret void
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep load
+
+define void @test(i32* %P) {
+        ; Dead but not deletable!
+        %X = volatile load i32* %P              ; <i32> [#uses=0]
+        ret void
 }
diff --git a/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll b/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll
index 837494f530..7daf7cb632 100644
--- a/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll
+++ b/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll
@@ -1,13 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep false
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep false
 ;
 ; This actually looks like a constant propagation bug
 
-%X = type { [10 x int], float }
+%X = type { [10 x i32], float }
 
-implementation
-
-bool %test() {
-	%A = getelementptr %X* null, long 0, uint 0, long 0
-	%B = setne int* %A, null
-	ret bool %B
+define i1 @test() {
+        %A = getelementptr %X* null, i64 0, i32 0, i64 0                ; <i32*> [#uses=1]
+        %B = icmp ne i32* %A, null              ; <i1> [#uses=1]
+        ret i1 %B
 }
+
diff --git a/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll b/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll
index d23dc32a07..7d219cb358 100644
--- a/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll
+++ b/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll
@@ -1,13 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-declare int* %bar()
+declare i32* @bar()
 
-float* %foo() {
-	%tmp.11 = invoke float* cast (int* ()* %bar to float* ()*)()
-			to label %invoke_cont except label %X
+define float* @foo() {
+        %tmp.11 = invoke float* bitcast (i32* ()* @bar to float* ()*)( )
+                        to label %invoke_cont unwind label %X           ; <float*> [#uses=1]
 
-invoke_cont:
-	ret float *%tmp.11
-X:
-	ret float *null
+invoke_cont:            ; preds = %0
+        ret float* %tmp.11
+
+X:              ; preds = %0
+        ret float* null
 }
+
diff --git a/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll b/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll
index a2e28d97a1..71585d4266 100644
--- a/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll
+++ b/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll
@@ -1,13 +1,13 @@
 ; The cast in this testcase is not eliminable on a 32-bit target!
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep inttoptr
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep inttoptr
 
-target endian = little
-target pointersize = 32
+target datalayout = "e-p:32:32"
 
-declare void %foo(...)
+declare void @foo(...)
 
-void %test(long %X) {
-	%Y = cast long %X to int*
-	call void (...)* %foo(int* %Y)
-	ret void
+define void @test(i64 %X) {
+        %Y = inttoptr i64 %X to i32*            ; <i32*> [#uses=1]
+        call void (...)* @foo( i32* %Y )
+        ret void
 }
+
diff --git a/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll b/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll
index d257286d85..23fe07d2b3 100644
--- a/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll
+++ b/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll
@@ -1,9 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep call | notcast
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep call | notcast
 
-declare void %free(sbyte*)
+declare void @free(i8*)
 
-void %test(int* %X) {
-	call int (...)* cast (void (sbyte*)* %free to int (...)*)(int * %X)
-	ret void
+define void @test(i32* %X) {
+        call i32 (...)* bitcast (void (i8*)* @free to i32 (...)*)( i32* %X )            ; <i32>:1 [#uses=0]
+        ret void
 }
 
diff --git a/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll b/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll
index ff90c32daf..c6a6b6afb8 100644
--- a/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll
+++ b/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll
@@ -5,20 +5,24 @@
 ; invoke instruction, we really cannot perform this transformation at all at
 ; least without splitting the critical edge.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-declare sbyte* %test()
+declare i8* @test()
 
-int %foo() {
+define i32 @foo() {
 entry:
-  br bool true, label %cont, label %call
-call:
-  %P = invoke int*()* cast (sbyte*()* %test to int*()*)()
-       to label %cont except label %N
-cont:
-  %P2 = phi int* [%P, %call], [null, %entry]
-  %V = load int* %P2
-  ret int %V
-N:
-  ret int 0
+        br i1 true, label %cont, label %call
+
+call:           ; preds = %entry
+        %P = invoke i32* bitcast (i8* ()* @test to i32* ()*)( )
+                        to label %cont unwind label %N          ; <i32*> [#uses=1]
+
+cont:           ; preds = %call, %entry
+        %P2 = phi i32* [ %P, %call ], [ null, %entry ]          ; <i32*> [#uses=1]
+        %V = load i32* %P2              ; <i32> [#uses=1]
+        ret i32 %V
+
+N:              ; preds = %call
+        ret i32 0
 }
+
diff --git a/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll b/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll
index 85095bf005..3a4b66157d 100644
--- a/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll
+++ b/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll
@@ -1,15 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 34
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep 34
 
-int %test(int %X) {
-	; Do not fold into shr X, 34, as this uses undefined behavior!
-	%Y = shr int %X, ubyte 17
-	%Z = shr int %Y, ubyte 17
-	ret int %Z
+define i32 @test(i32 %X) {
+        ; Do not fold into shr X, 34, as this uses undefined behavior!
+        %Y = ashr i32 %X, 17            ; <i32> [#uses=1]
+        %Z = ashr i32 %Y, 17            ; <i32> [#uses=1]
+        ret i32 %Z
 }
 
-int %test2(int %X) {
-	; Do not fold into shl X, 34, as this uses undefined behavior!
-	%Y = shl int %X, ubyte 17
-	%Z = shl int %Y, ubyte 17
-	ret int %Z
+define i32 @test2(i32 %X) {
+        ; Do not fold into shl X, 34, as this uses undefined behavior!
+        %Y = shl i32 %X, 17             ; <i32> [#uses=1]
+        %Z = shl i32 %Y, 17             ; <i32> [#uses=1]
+        ret i32 %Z
 }
diff --git a/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll b/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll
index fd7a2e346c..2b5481b019 100644
--- a/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll
+++ b/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll
@@ -1,13 +1,13 @@
 ; This testcase caused the combiner to go into an infinite loop, moving the 
 ; cast back and forth, changing the seteq to operate on int vs uint and back.
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-bool %test(uint %A, int %B) {
-        %C = sub uint 0, %A
-        %Cc = cast uint %C to int
-        %D = sub int 0, %B
-        %E = seteq int %Cc, %D
-        ret bool %E
+define i1 @test(i32 %A, i32 %B) {
+        %C = sub i32 0, %A              ; <i32> [#uses=1]
+        %Cc = bitcast i32 %C to i32             ; <i32> [#uses=1]
+        %D = sub i32 0, %B              ; <i32> [#uses=1]
+        %E = icmp eq i32 %Cc, %D                ; <i1> [#uses=1]
+        ret i1 %E
 }
 
diff --git a/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll b/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll
index 4c6ff1b52b..0b93eb2322 100644
--- a/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll
+++ b/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll
@@ -1,8 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-int %test() {
-	ret int 0
-Loop:
-	%X = add int %X, 1
-	br label %Loop
+define i32 @test() {
+        ret i32 0
+
+Loop:           ; preds = %Loop
+        %X = add i32 %X, 1              ; <i32> [#uses=1]
+        br label %Loop
 }
+
diff --git a/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll b/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll
index 8e8f019c66..66a5a4d78f 100644
--- a/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll
+++ b/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll
@@ -1,9 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
 %Ty = type opaque
 
-int %test(%Ty *%X) {
-	%Y = cast %Ty* %X to int*
-	%Z = load int* %Y
-	ret int %Z
+define i32 @test(%Ty* %X) {
+        %Y = bitcast %Ty* %X to i32*            ; <i32*> [#uses=1]
+        %Z = load i32* %Y               ; <i32> [#uses=1]
+        ret i32 %Z
 }
+
diff --git a/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll b/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll
index 7994d45c9f..82eecbb698 100644
--- a/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll
+++ b/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll
@@ -1,8 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-%p = weak global int 0
+@p = weak global i32 0          ; <i32*> [#uses=1]
 
-int %test(int %x) {
-	%y = mul int %x, cast (int* %p to int)
-	ret int %y
+define i32 @test(i32 %x) {
+        %y = mul i32 %x, ptrtoint (i32* @p to i32)              ; <i32> [#uses=1]
+        ret i32 %y
 }
+
diff --git a/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx b/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx
index 98b35fe3cb..9fc48de4ec 100644
--- a/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx
+++ b/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx
@@ -1,8 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
+; RUN: llvm-as < %s | opt -instcombine
 
 ; This testcase should not send the instcombiner into an infinite loop!
 
-int %test(int %X) {
-	%Y = rem int %X, 0
-	ret int %Y
+define i32 @test(i32 %X) {
+        %Y = srem i32 %X, 0             ; <i32> [#uses=1]
+        ret i32 %Y
 }
+
diff --git a/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll b/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll
index e87e42c198..5d2ed0b86d 100644
--- a/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll
+++ b/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll
@@ -1,7 +1,8 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep {ret i1 false}
-bool %test(bool %V) {
-	%Y = setlt bool %V, false
-	ret bool %Y
+
+define i1 @test(i1 %V) {
+        %Y = icmp ult i1 %V, false              ; <i1> [#uses=1]
+        ret i1 %Y
 }
 
diff --git a/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx b/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx
index ddc40394aa..e56c390d13 100644
--- a/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx
+++ b/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx
@@ -1,21 +1,18 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -mem2reg | llvm-dis | \
-; RUN:   not grep {int 1}
+; RUN: llvm-as < %s | opt -instcombine -mem2reg | llvm-dis | \
+; RUN:   not grep {i32 1}
 
 ; When propagating the load through the select, make sure that the load is
 ; inserted where the original load was, not where the select is.  Not doing
 ; so could produce incorrect results!
 
-implementation
-
-int %test(bool %C) {
-	%X = alloca int
-	%X2 = alloca int
-	store int 1, int* %X
-	store int 2, int* %X2
-
-        %Y = select bool %C, int* %X, int* %X2
-	store int 3, int* %X
-        %Z = load int* %Y
-        ret int %Z
+define i32 @test(i1 %C) {
+        %X = alloca i32         ; <i32*> [#uses=3]
+        %X2 = alloca i32                ; <i32*> [#uses=2]
+        store i32 1, i32* %X
+        store i32 2, i32* %X2
+        %Y = select i1 %C, i32* %X, i32* %X2            ; <i32*> [#uses=1]
+        store i32 3, i32* %X
+        %Z = load i32* %Y               ; <i32> [#uses=1]
+        ret i32 %Z
 }
 
diff --git a/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx b/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx
index c3478a82a2..3585659452 100644
--- a/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx
+++ b/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx
@@ -1,24 +1,25 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -mem2reg -simplifycfg | \
+; RUN: llvm-as < %s | opt -instcombine -mem2reg -simplifycfg | \
 ; RUN:   llvm-dis | grep -v store | not grep {int 1}
 
 ; Test to make sure that instcombine does not accidentally propagate the load
 ; into the PHI, which would break the program.
 
-int %test(bool %C) {
+define i32 @test(i1 %C) {
 entry:
-	%X = alloca int
-	%X2 = alloca int
-	store int 1, int* %X
-	store int 2, int* %X2
-        br bool %C, label %cond_true.i, label %cond_continue.i
+        %X = alloca i32         ; <i32*> [#uses=3]
+        %X2 = alloca i32                ; <i32*> [#uses=2]
+        store i32 1, i32* %X
+        store i32 2, i32* %X2
+        br i1 %C, label %cond_true.i, label %cond_continue.i
 
-cond_true.i:
+cond_true.i:            ; preds = %entry
         br label %cond_continue.i
 
-cond_continue.i:
-        %mem_tmp.i.0 = phi int* [ %X, %cond_true.i ], [ %X2, %entry ]
-	store int 3, int* %X
-        %tmp.3 = load int* %mem_tmp.i.0
-        ret int %tmp.3
+cond_continue.i:                ; preds = %cond_true.i, %entry
+        %mem_tmp.i.0 = phi i32* [ %X, %cond_true.i ], [ %X2, %entry ]           ; <i32*> [#uses=1]
+        store i32 3, i32* %X
+        %tmp.3 = load i32* %mem_tmp.i.0         ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
+
diff --git a/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx b/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx
index bb55b5c67c..ee4f62c8d5 100644
--- a/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx
+++ b/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx
@@ -1,9 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep -- -65536
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep -- -65536
 
-bool %test(int %tmp.124) {
-        %tmp.125 = shl int %tmp.124, ubyte 8
-        %tmp.126.mask = and int %tmp.125, -16777216             ; <int> [#uses=1]
-        %tmp.128 = seteq int %tmp.126.mask, 167772160           ; <bool> [#uses=1]
-        ret bool %tmp.128
+define i1 @test(i32 %tmp.124) {
+        %tmp.125 = shl i32 %tmp.124, 8          ; <i32> [#uses=1]
+        %tmp.126.mask = and i32 %tmp.125, -16777216             ; <i32> [#uses=1]
+        %tmp.128 = icmp eq i32 %tmp.126.mask, 167772160         ; <i1> [#uses=1]
+        ret i1 %tmp.128
 }
 
diff --git a/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll b/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll
index 1a741c996f..766ba48be6 100644
--- a/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll
+++ b/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll
@@ -1,8 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep and
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep and
 
-sbyte %test21(sbyte %A) {
-        %C = shr sbyte %A, ubyte 7   ;; sign extend
-        %D = and sbyte %C, 1         ;; chop off sign
-        ret sbyte %D
+define i8 @test21(i8 %A) {
+        ;; sign extend
+        %C = ashr i8 %A, 7              ; <i8> [#uses=1]
+        ;; chop off sign
+        %D = and i8 %C, 1               ; <i8> [#uses=1]
+        ret i8 %D
 }
 
diff --git a/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll b/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll
index 7e12bbf5ae..836d1eb27a 100644
--- a/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll
+++ b/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll
@@ -1,136 +1,132 @@
 ; This test case tests the InstructionCombining optimization that
 ; reduces things like:
-;   %Y = cast sbyte %X to uint
-;   %C = setlt uint %Y, 1024
+;   %Y = sext i8 %X to i32 
+;   %C = icmp ult i32 %Y, 1024
 ; to
-;   %C = bool true
+;   %C = i1 true
 ; It includes test cases for different constant values, signedness of the
 ; cast operands, and types of setCC operators. In all cases, the cast should
 ; be eliminated. In many cases the setCC is also eliminated based on the
 ; constant value and the range of the casted value.
 ;
-; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s -o - | opt -instcombine | llvm-dis | \
 ; RUN:    notcast .*int
-; END.
 
-implementation   ; Functions:
-
-bool %lt_signed_to_large_unsigned(sbyte %SB) {
-  %Y = cast sbyte %SB to uint		; <uint> [#uses=1]
-  %C = setlt uint %Y, 1024		; <bool> [#uses=1]
-  ret bool %C
+define i1 @lt_signed_to_large_unsigned(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ult i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_signed_to_large_signed(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setlt int %Y, 1024
-  ret bool %C
+define i1 @lt_signed_to_large_signed(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_signed_to_large_negative(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setlt int %Y, -1024
-  ret bool %C
+define i1 @lt_signed_to_large_negative(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, -1024             ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_signed_to_small_signed(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setlt int %Y, 17
-  ret bool %C
+define i1 @lt_signed_to_small_signed(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, 17                ; <i1> [#uses=1]
+        ret i1 %C
 }
-
-bool %lt_signed_to_small_negative(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setlt int %Y, -17
-  ret bool %C
+define i1 @lt_signed_to_small_negative(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, -17               ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_unsigned_to_large_unsigned(ubyte %SB) {
-  %Y = cast ubyte %SB to uint		; <uint> [#uses=1]
-  %C = setlt uint %Y, 1024		; <bool> [#uses=1]
-  ret bool %C
+define i1 @lt_unsigned_to_large_unsigned(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ult i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_unsigned_to_large_signed(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setlt int %Y, 1024
-  ret bool %C
+define i1 @lt_unsigned_to_large_signed(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_unsigned_to_large_negative(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setlt int %Y, -1024
-  ret bool %C
+define i1 @lt_unsigned_to_large_negative(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, -1024             ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_unsigned_to_small_unsigned(ubyte %SB) {
-  %Y = cast ubyte %SB to uint		; <uint> [#uses=1]
-  %C = setlt uint %Y, 17		; <bool> [#uses=1]
-  ret bool %C
+define i1 @lt_unsigned_to_small_unsigned(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ult i32 %Y, 17                ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %lt_unsigned_to_small_negative(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setlt int %Y, -17
-  ret bool %C
+define i1 @lt_unsigned_to_small_negative(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp slt i32 %Y, -17               ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_signed_to_large_unsigned(sbyte %SB) {
-  %Y = cast sbyte %SB to uint		; <uint> [#uses=1]
-  %C = setgt uint %Y, 1024		; <bool> [#uses=1]
-  ret bool %C
+define i1 @gt_signed_to_large_unsigned(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ugt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_signed_to_large_signed(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setgt int %Y, 1024
-  ret bool %C
+define i1 @gt_signed_to_large_signed(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_signed_to_large_negative(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setgt int %Y, -1024
-  ret bool %C
+define i1 @gt_signed_to_large_negative(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, -1024             ; <i1> [#uses=1]
+        ret i1 %C
 }
-
-bool %gt_signed_to_small_signed(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setgt int %Y, 17
-  ret bool %C
+define i1 @gt_signed_to_small_signed(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, 17                ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_signed_to_small_negative(sbyte %SB) {
-  %Y = cast sbyte %SB to int
-  %C = setgt int %Y, -17
-  ret bool %C
+define i1 @gt_signed_to_small_negative(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, -17               ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_unsigned_to_large_unsigned(ubyte %SB) {
-  %Y = cast ubyte %SB to uint		; <uint> [#uses=1]
-  %C = setgt uint %Y, 1024		; <bool> [#uses=1]
-  ret bool %C
+define i1 @gt_unsigned_to_large_unsigned(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ugt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_unsigned_to_large_signed(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setgt int %Y, 1024
-  ret bool %C
+define i1 @gt_unsigned_to_large_signed(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, 1024              ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_unsigned_to_large_negative(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setgt int %Y, -1024
-  ret bool %C
+define i1 @gt_unsigned_to_large_negative(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, -1024             ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_unsigned_to_small_unsigned(ubyte %SB) {
-  %Y = cast ubyte %SB to uint		; <uint> [#uses=1]
-  %C = setgt uint %Y, 17		; <bool> [#uses=1]
-  ret bool %C
+define i1 @gt_unsigned_to_small_unsigned(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp ugt i32 %Y, 17                ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %gt_unsigned_to_small_negative(ubyte %SB) {
-  %Y = cast ubyte %SB to int
-  %C = setgt int %Y, -17
-  ret bool %C
+define i1 @gt_unsigned_to_small_negative(i8 %SB) {
+        %Y = zext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp sgt i32 %Y, -17               ; <i1> [#uses=1]
+        ret i1 %C
 }
+
diff --git a/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll b/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll
index 6e241f4e78..5908205203 100644
--- a/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll
+++ b/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll
@@ -1,14 +1,14 @@
-; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine
+; RUN: llvm-as %s -o - | opt -instcombine
 
-	%struct.llvm_java_object_base = type opaque
-	"java/lang/Object" = type { %struct.llvm_java_object_base }
-	"java/lang/StringBuffer" = type { "java/lang/Object", int, { "java/lang/Object", uint, [0 x ushort] }*, bool }
 
-implementation   ; Functions:
+%"java/lang/Object" = type { %struct.llvm_java_object_base }
+%"java/lang/StringBuffer" = type { %"java/lang/Object", i32, { %"java/lang/Object", i32, [0 x i16] }*, i1 }
+%struct.llvm_java_object_base = type opaque
 
-void "java/lang/StringBuffer/append(Ljava/lang/String;)Ljava/lang/StringBuffer;"() {
+define void @"java/lang/StringBuffer/append(Ljava/lang/String;)Ljava/lang/StringBuffer;"() {
 bc0:
-	%tmp53 = getelementptr "java/lang/StringBuffer"* null, int 0, uint 1		; <int*> [#uses=1]
-	store int 0, int* %tmp53
-	ret void
+        %tmp53 = getelementptr %"java/lang/StringBuffer"* null, i32 0, i32 1            ; <i32*> [#uses=1]
+        store i32 0, i32* %tmp53
+        ret void
 }
+
diff --git a/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll b/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll
index fb18ea24c1..4ea0b5c484 100644
--- a/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll
+++ b/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll
@@ -1,6 +1,7 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine
+; RUN: llvm-as < %s | opt -instcombine
 
-int %test(int %X) {
-	%Y = rem int %X, undef
-	ret int %Y
+define i32 @test(i32 %X) {
+        %Y = srem i32 %X, undef         ; <i32> [#uses=1]
+        ret i32 %Y
 }
+
diff --git a/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll b/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll
index 9a754d842e..ffaa0051e9 100644
--- a/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll
+++ b/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll
@@ -1,9 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
-; RUN:   not grep {ret bool false}
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
+; RUN:   not grep {ret i1 false}
 
-bool %test(ulong %tmp.169) {
-	%tmp.1710 = shr ulong %tmp.169, ubyte 1
-	%tmp.1912 = setgt ulong %tmp.1710, 0
-	ret bool %tmp.1912
+define i1 @test(i64 %tmp.169) {
+        %tmp.1710 = lshr i64 %tmp.169, 1                ; <i64> [#uses=1]
+        %tmp.1912 = icmp ugt i64 %tmp.1710, 0           ; <i1> [#uses=1]
+        ret i1 %tmp.1912
 }
 
diff --git a/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll b/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll
index 8e523d3fae..8b2aa35bd7 100644
--- a/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll
+++ b/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll
@@ -1,7 +1,8 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-uint %test(bool %C, uint %tmp.15) {
-	%tmp.16 = select bool %C, uint 8, uint 1
-	%tmp.18 = div uint %tmp.15, %tmp.16
-	ret uint %tmp.18
+define i32 @test(i1 %C, i32 %tmp.15) {
+        %tmp.16 = select i1 %C, i32 8, i32 1            ; <i32> [#uses=1]
+        %tmp.18 = udiv i32 %tmp.15, %tmp.16             ; <i32> [#uses=1]
+        ret i32 %tmp.18
 }
+
diff --git a/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll b/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll
index fa862fed2a..53585f9aa3 100644
--- a/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll
+++ b/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll
@@ -1,9 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-int %_Z13func_31585107li(int %l_39521025, int %l_59244666) {
-	%shortcirc_val = select bool false, uint 1, uint 0		; <uint> [#uses=1]
-	%tmp.8 = div uint 0, %shortcirc_val		; <uint> [#uses=1]
-	%tmp.9 = seteq uint %tmp.8, 0		; <bool> [#uses=1]
-	%retval = select bool %tmp.9, int %l_59244666, int -1621308501		; <int> [#uses=1]
-	ret int %retval
+define i32 @_Z13func_31585107li(i32 %l_39521025, i32 %l_59244666) {
+        %shortcirc_val = select i1 false, i32 1, i32 0          ; <i32> [#uses=1]
+        %tmp.8 = udiv i32 0, %shortcirc_val             ; <i32> [#uses=1]
+        %tmp.9 = icmp eq i32 %tmp.8, 0          ; <i1> [#uses=1]
+        %retval = select i1 %tmp.9, i32 %l_59244666, i32 -1621308501            ; <i32> [#uses=1]
+        ret i32 %retval
 }
+
diff --git a/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll b/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll
index deb61246cf..64bfec18df 100644
--- a/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll
+++ b/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll
@@ -1,8 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 ; PR577
 
-bool %test() {
-	%tmp.3 = shl int 0, ubyte 41		; <int> [#uses=1]
-	%tmp.4 = setne int %tmp.3, 0		; <bool> [#uses=1]
-	ret bool %tmp.4
+define i1 @test() {
+        %tmp.3 = shl i32 0, 41          ; <i32> [#uses=1]
+        %tmp.4 = icmp ne i32 %tmp.3, 0          ; <i1> [#uses=1]
+        ret i1 %tmp.4
 }
+
diff --git a/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll b/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll
index ef44301225..10dbfec21a 100644
--- a/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll
+++ b/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll
@@ -1,7 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 ; PR585
-bool %test() {
-	%tmp.26 = div int 0, -2147483648		; <int> [#uses=1]
-	%tmp.27 = seteq int %tmp.26, 0		; <bool> [#uses=1]
-	ret bool %tmp.27
+
+define i1 @test() {
+        %tmp.26 = sdiv i32 0, -2147483648               ; <i32> [#uses=1]
+        %tmp.27 = icmp eq i32 %tmp.26, 0                ; <i1> [#uses=1]
+        ret i1 %tmp.27
 }
+
diff --git a/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll b/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll
index 764b035b54..010087b4f4 100644
--- a/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll
+++ b/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll
@@ -1,16 +1,14 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep {ret i1 true}
 ; PR586
 
-%g_07918478 = external global uint		; <uint*> [#uses=1]
+@g_07918478 = external global i32               ; <i32*> [#uses=1]
 
-implementation   ; Functions:
-
-bool %test() {
-	%tmp.0 = load uint* %g_07918478		; <uint> [#uses=2]
-	%tmp.1 = setne uint %tmp.0, 0		; <bool> [#uses=1]
-	%tmp.4 = setlt uint %tmp.0, 4111		; <bool> [#uses=1]
-	%bothcond = or bool %tmp.1, %tmp.4		; <bool> [#uses=1]
-	ret bool %bothcond
+define i1 @test() {
+        %tmp.0 = load i32* @g_07918478          ; <i32> [#uses=2]
+        %tmp.1 = icmp ne i32 %tmp.0, 0          ; <i1> [#uses=1]
+        %tmp.4 = icmp ult i32 %tmp.0, 4111              ; <i1> [#uses=1]
+        %bothcond = or i1 %tmp.1, %tmp.4                ; <i1> [#uses=1]
+        ret i1 %bothcond
 }
 
diff --git a/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll b/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll
index be9837dc43..c58234a549 100644
--- a/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll
+++ b/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll
@@ -1,13 +1,14 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
 ; This example caused instcombine to spin into an infinite loop.
 
-void %test(int *%P) {
-	ret void
-Dead:
-	%X = phi int [%Y, %Dead]
-	%Y = div int %X, 10
-	store int %Y, int* %P
-	br label %Dead
+define void @test(i32* %P) {
+        ret void
+
+Dead:           ; preds = %Dead
+        %X = phi i32 [ %Y, %Dead ]              ; <i32> [#uses=1]
+        %Y = sdiv i32 %X, 10            ; <i32> [#uses=2]
+        store i32 %Y, i32* %P
+        br label %Dead
 }
 
diff --git a/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll b/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll
index e06dca914e..d7df5a01fb 100644
--- a/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll
+++ b/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll
@@ -1,22 +1,21 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output	
+; RUN: llvm-as < %s | opt -instcombine -disable-output	
 
-	%struct.rtx_const = type { uint, { %union.real_extract } }
-	%struct.rtx_def = type { int, [1 x %union.rtunion_def] }
-	%union.real_extract = type { double }
-	%union.rtunion_def = type { uint }
+        %struct.rtx_const = type { i32, { %union.real_extract } }
+        %struct.rtx_def = type { i32, [1 x %union.rtunion_def] }
+        %union.real_extract = type { double }
+        %union.rtunion_def = type { i32 }
 
-implementation   ; Functions:
-
-fastcc void %decode_rtx_const(%struct.rtx_def* %x, %struct.rtx_const* %value) {
-	%tmp.54 = getelementptr %struct.rtx_const* %value, int 0, uint 0		; <uint*> [#uses=1]
-	%tmp.56 = getelementptr %struct.rtx_def* %x, int 0, uint 0		; <int*> [#uses=1]
-	%tmp.57 = load int* %tmp.56		; <int> [#uses=1]
-	%tmp.58 = shl int %tmp.57, ubyte 8		; <int> [#uses=1]
-	%tmp.59 = shr int %tmp.58, ubyte 24		; <int> [#uses=1]
-	%tmp.60 = cast int %tmp.59 to ushort		; <ushort> [#uses=1]
-	%tmp.61 = cast ushort %tmp.60 to uint		; <uint> [#uses=1]
-	%tmp.62 = shl uint %tmp.61, ubyte 16		; <uint> [#uses=1]
-	%tmp.65 = or uint 0, %tmp.62		; <uint> [#uses=1]
-	store uint %tmp.65, uint* %tmp.54
-	ret void
+define fastcc void @decode_rtx_const(%struct.rtx_def* %x, %struct.rtx_const* %value) {
+        %tmp.54 = getelementptr %struct.rtx_const* %value, i32 0, i32 0         ; <i32*> [#uses=1]
+        %tmp.56 = getelementptr %struct.rtx_def* %x, i32 0, i32 0               ; <i32*> [#uses=1]
+        %tmp.57 = load i32* %tmp.56             ; <i32> [#uses=1]
+        %tmp.58 = shl i32 %tmp.57, 8            ; <i32> [#uses=1]
+        %tmp.59 = ashr i32 %tmp.58, 24          ; <i32> [#uses=1]
+        %tmp.60 = trunc i32 %tmp.59 to i16              ; <i16> [#uses=1]
+        %tmp.61 = zext i16 %tmp.60 to i32               ; <i32> [#uses=1]
+        %tmp.62 = shl i32 %tmp.61, 16           ; <i32> [#uses=1]
+        %tmp.65 = or i32 0, %tmp.62             ; <i32> [#uses=1]
+        store i32 %tmp.65, i32* %tmp.54
+        ret void
 }
+
diff --git a/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll b/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll
index 73ad700961..c89b0d54a9 100644
--- a/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll
+++ b/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll
@@ -1,9 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   not grep undef
 
-int %test(sbyte %A) {
-	%B = cast sbyte %A to int
-	%C = shr int %B, ubyte 8
-	ret int %C
+define i32 @test(i8 %A) {
+        %B = sext i8 %A to i32          ; <i32> [#uses=1]
+        %C = ashr i32 %B, 8             ; <i32> [#uses=1]
+        ret i32 %C
 }
 
+
diff --git a/test/Transforms/InstCombine/2006-02-28-Crash.ll b/test/Transforms/InstCombine/2006-02-28-Crash.ll
index 241c254dc4..1f3c9e8e67 100644
--- a/test/Transforms/InstCombine/2006-02-28-Crash.ll
+++ b/test/Transforms/InstCombine/2006-02-28-Crash.ll
@@ -1,6 +1,8 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-int %test() {
-        %tmp203 = seteq uint 1, 2               ; <bool> [#uses=1]
-        %tmp203 = cast bool %tmp203 to int              ; <int> [#uses=1]
-	ret int %tmp203
+; RUN: llvm-as < %s | opt -instcombine -disable-output
+
+define i32 @test() {
+        %tmp203 = icmp eq i32 1, 2              ; <i1> [#uses=1]
+        %tmp203.upgrd.1 = zext i1 %tmp203 to i32                ; <i32> [#uses=1]
+        ret i32 %tmp203.upgrd.1
 }
+
diff --git a/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll b/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll
index 314946085f..e4b2b39312 100644
--- a/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll
+++ b/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll
@@ -1,7 +1,8 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-float %test(<4 x float> %V) {
-	%V2 = insertelement <4 x float> %V, float 1.0, uint 3
-	%R = extractelement <4 x float> %V2, uint 2
-	ret float %R
+define float @test(<4 x float> %V) {
+        %V2 = insertelement <4 x float> %V, float 1.000000e+00, i32 3           ; <<4 x float>> [#uses=1]
+        %R = extractelement <4 x float> %V2, i32 2              ; <float> [#uses=1]
+        ret float %R
 }
+
diff --git a/test/Transforms/InstCombine/2006-04-01-InfLoop.ll b/test/Transforms/InstCombine/2006-04-01-InfLoop.ll
index 81c1690a6f..1a26b63c5d 100644
--- a/test/Transforms/InstCombine/2006-04-01-InfLoop.ll
+++ b/test/Transforms/InstCombine/2006-04-01-InfLoop.ll
@@ -1,78 +1,74 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-; END.
-
-	%struct.DecRefPicMarking_s = type { int, int, int, int, int, %struct.DecRefPicMarking_s* }
-	%struct.datapartition = type { %typedef.Bitstream*, %typedef.DecodingEnvironment, int (%struct.syntaxelement*, %struct.img_par*, %struct.inp_par*, %struct.datapartition*)* }
-	%struct.img_par = type { int, uint, uint, int, int*, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, [16 x [16 x ushort]], [6 x [32 x int]], [16 x [16 x int]], [4 x [12 x [4 x [4 x int]]]], [16 x int], int**, int*, int***, int**, int, int, int, int, %typedef.Slice*, %struct.macroblock*, int, int, int, int, int, int, int**, %struct.DecRefPicMarking_s*, int, int, int, int, int, int, int, uint, int, int, int, uint, uint, uint, uint, int, [3 x int], int, uint, int, uint, int, int, int, uint, uint, int, int, int, int, uint, uint, int***, int***, int****, int, int, uint, int, int, int, int, uint, uint, uint, uint, uint, uint, uint, int, int, int, int, int, int, int, int, int, int, int, uint, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, %struct.timeb, %struct.timeb, int, int, int, int, int, uint, int, int }
-	%struct.inp_par = type { [100 x sbyte], [100 x sbyte], [100 x sbyte], int, int, int, int, int, int, int }
-	%struct.macroblock = type { int, int, int, %struct.macroblock*, %struct.macroblock*, int, [2 x [4 x [4 x [2 x int]]]], int, long, long, int, int, [4 x int], [4 x int], int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int }
-	%struct.pix_pos = type { int, int, int, int, int, int }
-	%struct.storable_picture = type { uint, int, int, int, int, [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], uint, int, int, int, int, int, int, int, short, int, int, int, int, int, int, int, uint, uint, ushort**, ushort***, ubyte*, short**, sbyte***, long***, long***, short****, ubyte**, ubyte**, %struct.storable_picture*, %struct.storable_picture*, %struct.storable_picture*, int, int, int, int, int, int, int, int, int, int, int, int, int, [2 x int], int, %struct.DecRefPicMarking_s*, int }
-	%struct.syntaxelement = type { int, int, int, int, int, uint, int, int, void (int, int, int*, int*)*, void (%struct.syntaxelement*, %struct.inp_par*, %struct.img_par*, %typedef.DecodingEnvironment*)* }
-	%struct.timeb = type { int, ushort, short, short }
-	%typedef.BiContextType = type { ushort, ubyte }
-	%typedef.Bitstream = type { int, int, int, int, ubyte*, int }
-	%typedef.DecodingEnvironment = type { uint, uint, uint, uint, int, ubyte*, int* }
+; RUN: llvm-as < %s | opt -instcombine -disable-output
+	%struct.DecRefPicMarking_s = type { i32, i32, i32, i32, i32, %struct.DecRefPicMarking_s* }
+	%struct.datapartition = type { %typedef.Bitstream*, %typedef.DecodingEnvironment, i32 (%struct.syntaxelement*, %struct.img_par*, %struct.inp_par*, %struct.datapartition*)* }
+	%struct.img_par = type { i32, i32, i32, i32, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [16 x [16 x i16]], [6 x [32 x i32]], [16 x [16 x i32]], [4 x [12 x [4 x [4 x i32]]]], [16 x i32], i32**, i32*, i32***, i32**, i32, i32, i32, i32, %typedef.Slice*, %struct.macroblock*, i32, i32, i32, i32, i32, i32, i32**, %struct.DecRefPicMarking_s*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32***, i32***, i32****, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.timeb, %struct.timeb, i32, i32, i32, i32, i32, i32, i32, i32 }
+	%struct.inp_par = type { [100 x i8], [100 x i8], [100 x i8], i32, i32, i32, i32, i32, i32, i32 }
+	%struct.macroblock = type { i32, i32, i32, %struct.macroblock*, %struct.macroblock*, i32, [2 x [4 x [4 x [2 x i32]]]], i32, i64, i64, i32, i32, [4 x i32], [4 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
+	%struct.pix_pos = type { i32, i32, i32, i32, i32, i32 }
+	%struct.storable_picture = type { i32, i32, i32, i32, i32, [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], i32, i32, i32, i32, i32, i32, i32, i32, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16**, i16***, i8*, i16**, i8***, i64***, i64***, i16****, i8**, i8**, %struct.storable_picture*, %struct.storable_picture*, %struct.storable_picture*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [2 x i32], i32, %struct.DecRefPicMarking_s*, i32 }
+	%struct.syntaxelement = type { i32, i32, i32, i32, i32, i32, i32, i32, void (i32, i32, i32*, i32*)*, void (%struct.syntaxelement*, %struct.inp_par*, %struct.img_par*, %typedef.DecodingEnvironment*)* }
+	%struct.timeb = type { i32, i16, i16, i16 }
+	%typedef.BiContextType = type { i16, i8 }
+	%typedef.Bitstream = type { i32, i32, i32, i32, i8*, i32 }
+	%typedef.DecodingEnvironment = type { i32, i32, i32, i32, i32, i8*, i32* }
 	%typedef.MotionInfoContexts = type { [4 x [11 x %typedef.BiContextType]], [2 x [9 x %typedef.BiContextType]], [2 x [10 x %typedef.BiContextType]], [2 x [6 x %typedef.BiContextType]], [4 x %typedef.BiContextType], [4 x %typedef.BiContextType], [3 x %typedef.BiContextType] }
-	%typedef.Slice = type { int, int, int, int, uint, int, int, int, int, %struct.datapartition*, %typedef.MotionInfoContexts*, %typedef.TextureInfoContexts*, int, int*, int*, int*, int, int*, int*, int*, int (%struct.img_par*, %struct.inp_par*)*, int, int, int, int }
+	%typedef.Slice = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.datapartition*, %typedef.MotionInfoContexts*, %typedef.TextureInfoContexts*, i32, i32*, i32*, i32*, i32, i32*, i32*, i32*, i32 (%struct.img_par*, %struct.inp_par*)*, i32, i32, i32, i32 }
 	%typedef.TextureInfoContexts = type { [2 x %typedef.BiContextType], [4 x %typedef.BiContextType], [3 x [4 x %typedef.BiContextType]], [10 x [4 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [5 x %typedef.BiContextType]], [10 x [5 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]] }
-%dec_picture = external global %struct.storable_picture*		; <%struct.storable_picture**> [#uses=1]
-%last_dquant = external global int		; <int*> [#uses=1]
+@dec_picture = external global %struct.storable_picture*		; <%struct.storable_picture**> [#uses=1]
+@last_dquant = external global i32		; <i32*> [#uses=1]
 
-implementation   ; Functions:
-
-void %readCBP_CABAC(%struct.syntaxelement* %se, %struct.inp_par* %inp, %struct.img_par* %img.1, %typedef.DecodingEnvironment* %dep_dp) {
+define void @readCBP_CABAC(%struct.syntaxelement* %se, %struct.inp_par* %inp, %struct.img_par* %img.1, %typedef.DecodingEnvironment* %dep_dp) {
 entry:
 	%block_a = alloca %struct.pix_pos		; <%struct.pix_pos*> [#uses=5]
-	%tmp.1 = getelementptr %struct.img_par* %img.1, int 0, uint 37		; <%typedef.Slice**> [#uses=1]
+	%tmp.1 = getelementptr %struct.img_par* %img.1, i32 0, i32 37		; <%typedef.Slice**> [#uses=1]
 	%tmp.2 = load %typedef.Slice** %tmp.1		; <%typedef.Slice*> [#uses=1]
-	%tmp.3 = getelementptr %typedef.Slice* %tmp.2, int 0, uint 11		; <%typedef.TextureInfoContexts**> [#uses=1]
+	%tmp.3 = getelementptr %typedef.Slice* %tmp.2, i32 0, i32 11		; <%typedef.TextureInfoContexts**> [#uses=1]
 	%tmp.4 = load %typedef.TextureInfoContexts** %tmp.3		; <%typedef.TextureInfoContexts*> [#uses=3]
-	%tmp.6 = getelementptr %struct.img_par* %img.1, int 0, uint 38		; <%struct.macroblock**> [#uses=1]
+	%tmp.6 = getelementptr %struct.img_par* %img.1, i32 0, i32 38		; <%struct.macroblock**> [#uses=1]
 	%tmp.7 = load %struct.macroblock** %tmp.6		; <%struct.macroblock*> [#uses=1]
-	%tmp.9 = getelementptr %struct.img_par* %img.1, int 0, uint 1		; <uint*> [#uses=1]
-	%tmp.10 = load uint* %tmp.9		; <uint> [#uses=1]
-	%tmp.11 = cast uint %tmp.10 to int		; <int> [#uses=1]
-	%tmp.12 = getelementptr %struct.macroblock* %tmp.7, int %tmp.11		; <%struct.macroblock*> [#uses=18]
+	%tmp.9 = getelementptr %struct.img_par* %img.1, i32 0, i32 1		; <i32*> [#uses=1]
+	%tmp.10 = load i32* %tmp.9		; <i32> [#uses=1]
+	%tmp.11 = bitcast i32 %tmp.10 to i32		; <i32> [#uses=1]
+	%tmp.12 = getelementptr %struct.macroblock* %tmp.7, i32 %tmp.11		; <%struct.macroblock*> [#uses=18]
 	br label %loopentry.0
 
 loopentry.0:		; preds = %loopexit.1, %entry
-	%mask.1 = phi int [ undef, %entry ], [ %mask.0, %loopexit.1 ]		; <int> [#uses=1]
-	%cbp_bit.1 = phi int [ undef, %entry ], [ %cbp_bit.0, %loopexit.1 ]		; <int> [#uses=1]
-	%cbp.2 = phi int [ 0, %entry ], [ %cbp.1, %loopexit.1 ]		; <int> [#uses=5]
-	%curr_cbp_ctx.1 = phi int [ undef, %entry ], [ %curr_cbp_ctx.0, %loopexit.1 ]		; <int> [#uses=1]
-	%b.2 = phi int [ undef, %entry ], [ %b.1, %loopexit.1 ]		; <int> [#uses=1]
-	%a.2 = phi int [ undef, %entry ], [ %a.1, %loopexit.1 ]		; <int> [#uses=1]
-	%mb_y.0 = phi int [ 0, %entry ], [ %tmp.152, %loopexit.1 ]		; <int> [#uses=7]
-	%mb_x.0 = phi int [ undef, %entry ], [ %mb_x.1, %loopexit.1 ]		; <int> [#uses=0]
-	%tmp.14 = setle int %mb_y.0, 3		; <bool> [#uses=2]
-	%tmp.15 = cast bool %tmp.14 to int		; <int> [#uses=0]
-	br bool %tmp.14, label %no_exit.0, label %loopexit.0
+	%mask.1 = phi i32 [ undef, %entry ], [ %mask.0, %loopexit.1 ]		; <i32> [#uses=1]
+	%cbp_bit.1 = phi i32 [ undef, %entry ], [ %cbp_bit.0, %loopexit.1 ]		; <i32> [#uses=1]
+	%cbp.2 = phi i32 [ 0, %entry ], [ %cbp.1, %loopexit.1 ]		; <i32> [#uses=5]
+	%curr_cbp_ctx.1 = phi i32 [ undef, %entry ], [ %curr_cbp_ctx.0, %loopexit.1 ]		; <i32> [#uses=1]
+	%b.2 = phi i32 [ undef, %entry ], [ %b.1, %loopexit.1 ]		; <i32> [#uses=1]
+	%a.2 = phi i32 [ undef, %entry ], [ %a.1, %loopexit.1 ]		; <i32> [#uses=1]
+	%mb_y.0 = phi i32 [ 0, %entry ], [ %tmp.152, %loopexit.1 ]		; <i32> [#uses=7]
+	%mb_x.0 = phi i32 [ undef, %entry ], [ %mb_x.1, %loopexit.1 ]		; <i32> [#uses=0]
+	%tmp.14 = icmp sle i32 %mb_y.0, 3		; <i1> [#uses=2]
+	%tmp.15 = zext i1 %tmp.14 to i32		; <i32> [#uses=0]
+	br i1 %tmp.14, label %no_exit.0, label %loopexit.0
 
 no_exit.0:		; preds = %loopentry.0
 	br label %loopentry.1
 
 loopentry.1:		; preds = %endif.7, %no_exit.0
-	%mask.0 = phi int [ %mask.1, %no_exit.0 ], [ %tmp.131, %endif.7 ]		; <int> [#uses=1]
-	%cbp_bit.0 = phi int [ %cbp_bit.1, %no_exit.0 ], [ %tmp.142, %endif.7 ]		; <int> [#uses=1]
-	%cbp.1 = phi int [ %cbp.2, %no_exit.0 ], [ %cbp.0, %endif.7 ]		; <int> [#uses=5]
-	%curr_cbp_ctx.0 = phi int [ %curr_cbp_ctx.1, %no_exit.0 ], [ %tmp.125, %endif.7 ]		; <int> [#uses=1]
-	%b.1 = phi int [ %b.2, %no_exit.0 ], [ %b.0, %endif.7 ]		; <int> [#uses=1]
-	%a.1 = phi int [ %a.2, %no_exit.0 ], [ %a.0, %endif.7 ]		; <int> [#uses=1]
-	%mb_x.1 = phi int [ 0, %no_exit.0 ], [ %tmp.150, %endif.7 ]		; <int> [#uses=9]
-	%tmp.17 = setle int %mb_x.1, 3		; <bool> [#uses=2]
-	%tmp.18 = cast bool %tmp.17 to int		; <int> [#uses=0]
-	br bool %tmp.17, label %no_exit.1, label %loopexit.1
+	%mask.0 = phi i32 [ %mask.1, %no_exit.0 ], [ %tmp.131, %endif.7 ]		; <i32> [#uses=1]
+	%cbp_bit.0 = phi i32 [ %cbp_bit.1, %no_exit.0 ], [ %tmp.142, %endif.7 ]		; <i32> [#uses=1]
+	%cbp.1 = phi i32 [ %cbp.2, %no_exit.0 ], [ %cbp.0, %endif.7 ]		; <i32> [#uses=5]
+	%curr_cbp_ctx.0 = phi i32 [ %curr_cbp_ctx.1, %no_exit.0 ], [ %tmp.125, %endif.7 ]		; <i32> [#uses=1]
+	%b.1 = phi i32 [ %b.2, %no_exit.0 ], [ %b.0, %endif.7 ]		; <i32> [#uses=1]
+	%a.1 = phi i32 [ %a.2, %no_exit.0 ], [ %a.0, %endif.7 ]		; <i32> [#uses=1]
+	%mb_x.1 = phi i32 [ 0, %no_exit.0 ], [ %tmp.150, %endif.7 ]		; <i32> [#uses=9]
+	%tmp.17 = icmp sle i32 %mb_x.1, 3		; <i1> [#uses=2]
+	%tmp.18 = zext i1 %tmp.17 to i32		; <i32> [#uses=0]
+	br i1 %tmp.17, label %no_exit.1, label %loopexit.1
 
 no_exit.1:		; preds = %loopentry.1
-	%tmp.20 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 12		; <[4 x int]*> [#uses=1]
-	%tmp.22 = div int %mb_x.1, 2		; <int> [#uses=1]
-	%tmp.24 = add int %tmp.22, %mb_y.0		; <int> [#uses=1]
-	%tmp.25 = getelementptr [4 x int]* %tmp.20, int 0, int %tmp.24		; <int*> [#uses=1]
-	%tmp.26 = load int* %tmp.25		; <int> [#uses=1]
-	%tmp.27 = seteq int %tmp.26, 11		; <bool> [#uses=2]
-	%tmp.28 = cast bool %tmp.27 to int		; <int> [#uses=0]
-	br bool %tmp.27, label %then.0, label %else.0
+	%tmp.20 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 12		; <[4 x i32]*> [#uses=1]
+	%tmp.22 = sdiv i32 %mb_x.1, 2		; <i32> [#uses=1]
+	%tmp.24 = add i32 %tmp.22, %mb_y.0		; <i32> [#uses=1]
+	%tmp.25 = getelementptr [4 x i32]* %tmp.20, i32 0, i32 %tmp.24		; <i32*> [#uses=1]
+	%tmp.26 = load i32* %tmp.25		; <i32> [#uses=1]
+	%tmp.27 = icmp eq i32 %tmp.26, 11		; <i1> [#uses=2]
+	%tmp.28 = zext i1 %tmp.27 to i32		; <i32> [#uses=0]
+	br i1 %tmp.27, label %then.0, label %else.0
 
 then.0:		; preds = %no_exit.1
 	br label %endif.0
@@ -81,362 +77,367 @@ else.0:		; preds = %no_exit.1
 	br label %endif.0
 
 endif.0:		; preds = %else.0, %then.0
-	%tmp.30 = seteq int %mb_y.0, 0		; <bool> [#uses=2]
-	%tmp.31 = cast bool %tmp.30 to int		; <int> [#uses=0]
-	br bool %tmp.30, label %then.1, label %else.1
+	%tmp.30 = icmp eq i32 %mb_y.0, 0		; <i1> [#uses=2]
+	%tmp.31 = zext i1 %tmp.30 to i32		; <i32> [#uses=0]
+	br i1 %tmp.30, label %then.1, label %else.1
 
 then.1:		; preds = %endif.0
-	%tmp.33 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.33 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.34 = load %struct.macroblock** %tmp.33		; <%struct.macroblock*> [#uses=1]
-	%tmp.35 = cast %struct.macroblock* %tmp.34 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp.36 = seteq sbyte* %tmp.35, null		; <bool> [#uses=2]
-	%tmp.37 = cast bool %tmp.36 to int		; <int> [#uses=0]
-	br bool %tmp.36, label %then.2, label %else.2
+	%tmp.35 = bitcast %struct.macroblock* %tmp.34 to i8*		; <i8*> [#uses=1]
+	%tmp.36 = icmp eq i8* %tmp.35, null		; <i1> [#uses=2]
+	%tmp.37 = zext i1 %tmp.36 to i32		; <i32> [#uses=0]
+	br i1 %tmp.36, label %then.2, label %else.2
 
 then.2:		; preds = %then.1
 	br label %endif.1
 
 else.2:		; preds = %then.1
-	%tmp.39 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.39 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.40 = load %struct.macroblock** %tmp.39		; <%struct.macroblock*> [#uses=1]
-	%tmp.41 = getelementptr %struct.macroblock* %tmp.40, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.42 = load int* %tmp.41		; <int> [#uses=1]
-	%tmp.43 = seteq int %tmp.42, 14		; <bool> [#uses=2]
-	%tmp.44 = cast bool %tmp.43 to int		; <int> [#uses=0]
-	br bool %tmp.43, label %then.3, label %else.3
+	%tmp.41 = getelementptr %struct.macroblock* %tmp.40, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.42 = load i32* %tmp.41		; <i32> [#uses=1]
+	%tmp.43 = icmp eq i32 %tmp.42, 14		; <i1> [#uses=2]
+	%tmp.44 = zext i1 %tmp.43 to i32		; <i32> [#uses=0]
+	br i1 %tmp.43, label %then.3, label %else.3
 
 then.3:		; preds = %else.2
 	br label %endif.1
 
 else.3:		; preds = %else.2
-	%tmp.46 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.46 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.47 = load %struct.macroblock** %tmp.46		; <%struct.macroblock*> [#uses=1]
-	%tmp.48 = getelementptr %struct.macroblock* %tmp.47, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.49 = load int* %tmp.48		; <int> [#uses=1]
-	%tmp.51 = div int %mb_x.1, 2		; <int> [#uses=1]
-	%tmp.52 = add int %tmp.51, 2		; <int> [#uses=1]
-	%tmp.53 = cast int %tmp.52 to ubyte		; <ubyte> [#uses=1]
-	%tmp.54 = shr int %tmp.49, ubyte %tmp.53		; <int> [#uses=1]
-	%tmp.55 = cast int %tmp.54 to uint		; <uint> [#uses=1]
-	%tmp.57 = xor uint %tmp.55, 1		; <uint> [#uses=1]
-	%tmp.58 = cast uint %tmp.57 to int		; <int> [#uses=1]
-	%tmp.59 = and int %tmp.58, 1		; <int> [#uses=1]
+	%tmp.48 = getelementptr %struct.macroblock* %tmp.47, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.49 = load i32* %tmp.48		; <i32> [#uses=1]
+	%tmp.51 = sdiv i32 %mb_x.1, 2		; <i32> [#uses=1]
+	%tmp.52 = add i32 %tmp.51, 2		; <i32> [#uses=1]
+	%tmp.53 = trunc i32 %tmp.52 to i8		; <i8> [#uses=1]
+	%shift.upgrd.1 = zext i8 %tmp.53 to i32		; <i32> [#uses=1]
+	%tmp.54 = ashr i32 %tmp.49, %shift.upgrd.1		; <i32> [#uses=1]
+	%tmp.55 = bitcast i32 %tmp.54 to i32		; <i32> [#uses=1]
+	%tmp.57 = xor i32 %tmp.55, 1		; <i32> [#uses=1]
+	%tmp.58 = bitcast i32 %tmp.57 to i32		; <i32> [#uses=1]
+	%tmp.59 = and i32 %tmp.58, 1		; <i32> [#uses=1]
 	br label %endif.1
 
 else.1:		; preds = %endif.0
-	%tmp.62 = div int %mb_x.1, 2		; <int> [#uses=1]
-	%tmp.63 = cast int %tmp.62 to ubyte		; <ubyte> [#uses=1]
-	%tmp.64 = shr int %cbp.1, ubyte %tmp.63		; <int> [#uses=1]
-	%tmp.65 = cast int %tmp.64 to uint		; <uint> [#uses=1]
-	%tmp.67 = xor uint %tmp.65, 1		; <uint> [#uses=1]
-	%tmp.68 = cast uint %tmp.67 to int		; <int> [#uses=1]
-	%tmp.69 = and int %tmp.68, 1		; <int> [#uses=1]
+	%tmp.62 = sdiv i32 %mb_x.1, 2		; <i32> [#uses=1]
+	%tmp.63 = trunc i32 %tmp.62 to i8		; <i8> [#uses=1]
+	%shift.upgrd.2 = zext i8 %tmp.63 to i32		; <i32> [#uses=1]
+	%tmp.64 = ashr i32 %cbp.1, %shift.upgrd.2		; <i32> [#uses=1]
+	%tmp.65 = bitcast i32 %tmp.64 to i32		; <i32> [#uses=1]
+	%tmp.67 = xor i32 %tmp.65, 1		; <i32> [#uses=1]
+	%tmp.68 = bitcast i32 %tmp.67 to i32		; <i32> [#uses=1]
+	%tmp.69 = and i32 %tmp.68, 1		; <i32> [#uses=1]
 	br label %endif.1
 
 endif.1:		; preds = %else.1, %else.3, %then.3, %then.2
-	%b.0 = phi int [ 0, %then.2 ], [ 0, %then.3 ], [ %tmp.59, %else.3 ], [ %tmp.69, %else.1 ]		; <int> [#uses=2]
-	%tmp.71 = seteq int %mb_x.1, 0		; <bool> [#uses=2]
-	%tmp.72 = cast bool %tmp.71 to int		; <int> [#uses=0]
-	br bool %tmp.71, label %then.4, label %else.4
+	%b.0 = phi i32 [ 0, %then.2 ], [ 0, %then.3 ], [ %tmp.59, %else.3 ], [ %tmp.69, %else.1 ]		; <i32> [#uses=2]
+	%tmp.71 = icmp eq i32 %mb_x.1, 0		; <i1> [#uses=2]
+	%tmp.72 = zext i1 %tmp.71 to i32		; <i32> [#uses=0]
+	br i1 %tmp.71, label %then.4, label %else.4
 
 then.4:		; preds = %endif.1
-	%tmp.74 = getelementptr %struct.img_par* %img.1, int 0, uint 1		; <uint*> [#uses=1]
-	%tmp.75 = load uint* %tmp.74		; <uint> [#uses=1]
-	%tmp.76 = cast uint %tmp.75 to int		; <int> [#uses=1]
-	call void %getLuma4x4Neighbour( int %tmp.76, int %mb_x.1, int %mb_y.0, int -1, int 0, %struct.pix_pos* %block_a )
-	%tmp.79 = getelementptr %struct.pix_pos* %block_a, int 0, uint 0		; <int*> [#uses=1]
-	%tmp.80 = load int* %tmp.79		; <int> [#uses=1]
-	%tmp.81 = setne int %tmp.80, 0		; <bool> [#uses=2]
-	%tmp.82 = cast bool %tmp.81 to int		; <int> [#uses=0]
-	br bool %tmp.81, label %then.5, label %else.5
+	%tmp.74 = getelementptr %struct.img_par* %img.1, i32 0, i32 1		; <i32*> [#uses=1]
+	%tmp.75 = load i32* %tmp.74		; <i32> [#uses=1]
+	%tmp.76 = bitcast i32 %tmp.75 to i32		; <i32> [#uses=1]
+	call void @getLuma4x4Neighbour( i32 %tmp.76, i32 %mb_x.1, i32 %mb_y.0, i32 -1, i32 0, %struct.pix_pos* %block_a )
+	%tmp.79 = getelementptr %struct.pix_pos* %block_a, i32 0, i32 0		; <i32*> [#uses=1]
+	%tmp.80 = load i32* %tmp.79		; <i32> [#uses=1]
+	%tmp.81 = icmp ne i32 %tmp.80, 0		; <i1> [#uses=2]
+	%tmp.82 = zext i1 %tmp.81 to i32		; <i32> [#uses=0]
+	br i1 %tmp.81, label %then.5, label %else.5
 
 then.5:		; preds = %then.4
-	%tmp.84 = getelementptr %struct.img_par* %img.1, int 0, uint 38		; <%struct.macroblock**> [#uses=1]
+	%tmp.84 = getelementptr %struct.img_par* %img.1, i32 0, i32 38		; <%struct.macroblock**> [#uses=1]
 	%tmp.85 = load %struct.macroblock** %tmp.84		; <%struct.macroblock*> [#uses=1]
-	%tmp.86 = getelementptr %struct.pix_pos* %block_a, int 0, uint 1		; <int*> [#uses=1]
-	%tmp.87 = load int* %tmp.86		; <int> [#uses=1]
-	%tmp.88 = getelementptr %struct.macroblock* %tmp.85, int %tmp.87		; <%struct.macroblock*> [#uses=1]
-	%tmp.89 = getelementptr %struct.macroblock* %tmp.88, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.90 = load int* %tmp.89		; <int> [#uses=1]
-	%tmp.91 = seteq int %tmp.90, 14		; <bool> [#uses=2]
-	%tmp.92 = cast bool %tmp.91 to int		; <int> [#uses=0]
-	br bool %tmp.91, label %then.6, label %else.6
+	%tmp.86 = getelementptr %struct.pix_pos* %block_a, i32 0, i32 1		; <i32*> [#uses=1]
+	%tmp.87 = load i32* %tmp.86		; <i32> [#uses=1]
+	%tmp.88 = getelementptr %struct.macroblock* %tmp.85, i32 %tmp.87		; <%struct.macroblock*> [#uses=1]
+	%tmp.89 = getelementptr %struct.macroblock* %tmp.88, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.90 = load i32* %tmp.89		; <i32> [#uses=1]
+	%tmp.91 = icmp eq i32 %tmp.90, 14		; <i1> [#uses=2]
+	%tmp.92 = zext i1 %tmp.91 to i32		; <i32> [#uses=0]
+	br i1 %tmp.91, label %then.6, label %else.6
 
 then.6:		; preds = %then.5
 	br label %endif.4
 
 else.6:		; preds = %then.5
-	%tmp.94 = getelementptr %struct.img_par* %img.1, int 0, uint 38		; <%struct.macroblock**> [#uses=1]
+	%tmp.94 = getelementptr %struct.img_par* %img.1, i32 0, i32 38		; <%struct.macroblock**> [#uses=1]
 	%tmp.95 = load %struct.macroblock** %tmp.94		; <%struct.macroblock*> [#uses=1]
-	%tmp.96 = getelementptr %struct.pix_pos* %block_a, int 0, uint 1		; <int*> [#uses=1]
-	%tmp.97 = load int* %tmp.96		; <int> [#uses=1]
-	%tmp.98 = getelementptr %struct.macroblock* %tmp.95, int %tmp.97		; <%struct.macroblock*> [#uses=1]
-	%tmp.99 = getelementptr %struct.macroblock* %tmp.98, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.100 = load int* %tmp.99		; <int> [#uses=1]
-	%tmp.101 = getelementptr %struct.pix_pos* %block_a, int 0, uint 3		; <int*> [#uses=1]
-	%tmp.102 = load int* %tmp.101		; <int> [#uses=1]
-	%tmp.103 = div int %tmp.102, 2		; <int> [#uses=1]
-	%tmp.104 = mul int %tmp.103, 2		; <int> [#uses=1]
-	%tmp.105 = add int %tmp.104, 1		; <int> [#uses=1]
-	%tmp.106 = cast int %tmp.105 to ubyte		; <ubyte> [#uses=1]
-	%tmp.107 = shr int %tmp.100, ubyte %tmp.106		; <int> [#uses=1]
-	%tmp.108 = cast int %tmp.107 to uint		; <uint> [#uses=1]
-	%tmp.110 = xor uint %tmp.108, 1		; <uint> [#uses=1]
-	%tmp.111 = cast uint %tmp.110 to int		; <int> [#uses=1]
-	%tmp.112 = and int %tmp.111, 1		; <int> [#uses=1]
+	%tmp.96 = getelementptr %struct.pix_pos* %block_a, i32 0, i32 1		; <i32*> [#uses=1]
+	%tmp.97 = load i32* %tmp.96		; <i32> [#uses=1]
+	%tmp.98 = getelementptr %struct.macroblock* %tmp.95, i32 %tmp.97		; <%struct.macroblock*> [#uses=1]
+	%tmp.99 = getelementptr %struct.macroblock* %tmp.98, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.100 = load i32* %tmp.99		; <i32> [#uses=1]
+	%tmp.101 = getelementptr %struct.pix_pos* %block_a, i32 0, i32 3		; <i32*> [#uses=1]
+	%tmp.102 = load i32* %tmp.101		; <i32> [#uses=1]
+	%tmp.103 = sdiv i32 %tmp.102, 2		; <i32> [#uses=1]
+	%tmp.104 = mul i32 %tmp.103, 2		; <i32> [#uses=1]
+	%tmp.105 = add i32 %tmp.104, 1		; <i32> [#uses=1]
+	%tmp.106 = trunc i32 %tmp.105 to i8		; <i8> [#uses=1]
+	%shift.upgrd.3 = zext i8 %tmp.106 to i32		; <i32> [#uses=1]
+	%tmp.107 = ashr i32 %tmp.100, %shift.upgrd.3		; <i32> [#uses=1]
+	%tmp.108 = bitcast i32 %tmp.107 to i32		; <i32> [#uses=1]
+	%tmp.110 = xor i32 %tmp.108, 1		; <i32> [#uses=1]
+	%tmp.111 = bitcast i32 %tmp.110 to i32		; <i32> [#uses=1]
+	%tmp.112 = and i32 %tmp.111, 1		; <i32> [#uses=1]
 	br label %endif.4
 
 else.5:		; preds = %then.4
 	br label %endif.4
 
 else.4:		; preds = %endif.1
-	%tmp.115 = cast int %mb_y.0 to ubyte		; <ubyte> [#uses=1]
-	%tmp.116 = shr int %cbp.1, ubyte %tmp.115		; <int> [#uses=1]
-	%tmp.117 = cast int %tmp.116 to uint		; <uint> [#uses=1]
-	%tmp.119 = xor uint %tmp.117, 1		; <uint> [#uses=1]
-	%tmp.120 = cast uint %tmp.119 to int		; <int> [#uses=1]
-	%tmp.121 = and int %tmp.120, 1		; <int> [#uses=1]
+	%tmp.115 = trunc i32 %mb_y.0 to i8		; <i8> [#uses=1]
+	%shift.upgrd.4 = zext i8 %tmp.115 to i32		; <i32> [#uses=1]
+	%tmp.116 = ashr i32 %cbp.1, %shift.upgrd.4		; <i32> [#uses=1]
+	%tmp.117 = bitcast i32 %tmp.116 to i32		; <i32> [#uses=1]
+	%tmp.119 = xor i32 %tmp.117, 1		; <i32> [#uses=1]
+	%tmp.120 = bitcast i32 %tmp.119 to i32		; <i32> [#uses=1]
+	%tmp.121 = and i32 %tmp.120, 1		; <i32> [#uses=1]
 	br label %endif.4
 
 endif.4:		; preds = %else.4, %else.5, %else.6, %then.6
-	%a.0 = phi int [ 0, %then.6 ], [ %tmp.112, %else.6 ], [ 0, %else.5 ], [ %tmp.121, %else.4 ]		; <int> [#uses=2]
-	%tmp.123 = mul int %b.0, 2		; <int> [#uses=1]
-	%tmp.125 = add int %tmp.123, %a.0		; <int> [#uses=2]
-	%tmp.127 = div int %mb_x.1, 2		; <int> [#uses=1]
-	%tmp.129 = add int %tmp.127, %mb_y.0		; <int> [#uses=1]
-	%tmp.130 = cast int %tmp.129 to ubyte		; <ubyte> [#uses=1]
-	%tmp.131 = shl int 1, ubyte %tmp.130		; <int> [#uses=2]
-	%tmp.135 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
-	%tmp.136 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.135, int 0, int 0		; <[4 x %typedef.BiContextType]*> [#uses=1]
-	%tmp.137 = getelementptr [4 x %typedef.BiContextType]* %tmp.136, int 0, int 0		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.139 = cast int %tmp.125 to uint		; <uint> [#uses=1]
-	%tmp.140 = cast uint %tmp.139 to int		; <int> [#uses=1]
-	%tmp.141 = getelementptr %typedef.BiContextType* %tmp.137, int %tmp.140		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.132 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.141 )		; <uint> [#uses=1]
-	%tmp.142 = cast uint %tmp.132 to int		; <int> [#uses=2]
-	%tmp.144 = setne int %tmp.142, 0		; <bool> [#uses=2]
-	%tmp.145 = cast bool %tmp.144 to int		; <int> [#uses=0]
-	br bool %tmp.144, label %then.7, label %endif.7
+	%a.0 = phi i32 [ 0, %then.6 ], [ %tmp.112, %else.6 ], [ 0, %else.5 ], [ %tmp.121, %else.4 ]		; <i32> [#uses=2]
+	%tmp.123 = mul i32 %b.0, 2		; <i32> [#uses=1]
+	%tmp.125 = add i32 %tmp.123, %a.0		; <i32> [#uses=2]
+	%tmp.127 = sdiv i32 %mb_x.1, 2		; <i32> [#uses=1]
+	%tmp.129 = add i32 %tmp.127, %mb_y.0		; <i32> [#uses=1]
+	%tmp.130 = trunc i32 %tmp.129 to i8		; <i8> [#uses=1]
+	%shift.upgrd.5 = zext i8 %tmp.130 to i32		; <i32> [#uses=1]
+	%tmp.131 = shl i32 1, %shift.upgrd.5		; <i32> [#uses=2]
+	%tmp.135 = getelementptr %typedef.TextureInfoContexts* %tmp.4, i32 0, i32 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
+	%tmp.136 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.135, i32 0, i32 0		; <[4 x %typedef.BiContextType]*> [#uses=1]
+	%tmp.137 = getelementptr [4 x %typedef.BiContextType]* %tmp.136, i32 0, i32 0		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.139 = bitcast i32 %tmp.125 to i32		; <i32> [#uses=1]
+	%tmp.140 = bitcast i32 %tmp.139 to i32		; <i32> [#uses=1]
+	%tmp.141 = getelementptr %typedef.BiContextType* %tmp.137, i32 %tmp.140		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.132 = call i32 @biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.141 )		; <i32> [#uses=1]
+	%tmp.142 = bitcast i32 %tmp.132 to i32		; <i32> [#uses=2]
+	%tmp.144 = icmp ne i32 %tmp.142, 0		; <i1> [#uses=2]
+	%tmp.145 = zext i1 %tmp.144 to i32		; <i32> [#uses=0]
+	br i1 %tmp.144, label %then.7, label %endif.7
 
 then.7:		; preds = %endif.4
-	%tmp.148 = add int %cbp.1, %tmp.131		; <int> [#uses=1]
+	%tmp.148 = add i32 %cbp.1, %tmp.131		; <i32> [#uses=1]
 	br label %endif.7
 
 endif.7:		; preds = %then.7, %endif.4
-	%cbp.0 = phi int [ %tmp.148, %then.7 ], [ %cbp.1, %endif.4 ]		; <int> [#uses=1]
-	%tmp.150 = add int %mb_x.1, 2		; <int> [#uses=1]
+	%cbp.0 = phi i32 [ %tmp.148, %then.7 ], [ %cbp.1, %endif.4 ]		; <i32> [#uses=1]
+	%tmp.150 = add i32 %mb_x.1, 2		; <i32> [#uses=1]
 	br label %loopentry.1
 
 loopexit.1:		; preds = %loopentry.1
-	%tmp.152 = add int %mb_y.0, 2		; <int> [#uses=1]
+	%tmp.152 = add i32 %mb_y.0, 2		; <i32> [#uses=1]
 	br label %loopentry.0
 
 loopexit.0:		; preds = %loopentry.0
-	%tmp.153 = load %struct.storable_picture** %dec_picture		; <%struct.storable_picture*> [#uses=1]
-	%tmp.154 = getelementptr %struct.storable_picture* %tmp.153, int 0, uint 45		; <int*> [#uses=1]
-	%tmp.155 = load int* %tmp.154		; <int> [#uses=1]
-	%tmp.156 = setne int %tmp.155, 0		; <bool> [#uses=2]
-	%tmp.157 = cast bool %tmp.156 to int		; <int> [#uses=0]
-	br bool %tmp.156, label %then.8, label %endif.8
+	%tmp.153 = load %struct.storable_picture** @dec_picture		; <%struct.storable_picture*> [#uses=1]
+	%tmp.154 = getelementptr %struct.storable_picture* %tmp.153, i32 0, i32 45		; <i32*> [#uses=1]
+	%tmp.155 = load i32* %tmp.154		; <i32> [#uses=1]
+	%tmp.156 = icmp ne i32 %tmp.155, 0		; <i1> [#uses=2]
+	%tmp.157 = zext i1 %tmp.156 to i32		; <i32> [#uses=0]
+	br i1 %tmp.156, label %then.8, label %endif.8
 
 then.8:		; preds = %loopexit.0
-	%tmp.159 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.159 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.160 = load %struct.macroblock** %tmp.159		; <%struct.macroblock*> [#uses=1]
-	%tmp.161 = cast %struct.macroblock* %tmp.160 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp.162 = setne sbyte* %tmp.161, null		; <bool> [#uses=2]
-	%tmp.163 = cast bool %tmp.162 to int		; <int> [#uses=0]
-	br bool %tmp.162, label %then.9, label %endif.9
+	%tmp.161 = bitcast %struct.macroblock* %tmp.160 to i8*		; <i8*> [#uses=1]
+	%tmp.162 = icmp ne i8* %tmp.161, null		; <i1> [#uses=2]
+	%tmp.163 = zext i1 %tmp.162 to i32		; <i32> [#uses=0]
+	br i1 %tmp.162, label %then.9, label %endif.9
 
 then.9:		; preds = %then.8
-	%tmp.165 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.165 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.166 = load %struct.macroblock** %tmp.165		; <%struct.macroblock*> [#uses=1]
-	%tmp.167 = getelementptr %struct.macroblock* %tmp.166, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.168 = load int* %tmp.167		; <int> [#uses=1]
-	%tmp.169 = seteq int %tmp.168, 14		; <bool> [#uses=2]
-	%tmp.170 = cast bool %tmp.169 to int		; <int> [#uses=0]
-	br bool %tmp.169, label %then.10, label %else.7
+	%tmp.167 = getelementptr %struct.macroblock* %tmp.166, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.168 = load i32* %tmp.167		; <i32> [#uses=1]
+	%tmp.169 = icmp eq i32 %tmp.168, 14		; <i1> [#uses=2]
+	%tmp.170 = zext i1 %tmp.169 to i32		; <i32> [#uses=0]
+	br i1 %tmp.169, label %then.10, label %else.7
 
 then.10:		; preds = %then.9
 	br label %endif.9
 
 else.7:		; preds = %then.9
-	%tmp.172 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.172 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.173 = load %struct.macroblock** %tmp.172		; <%struct.macroblock*> [#uses=1]
-	%tmp.174 = getelementptr %struct.macroblock* %tmp.173, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.175 = load int* %tmp.174		; <int> [#uses=1]
-	%tmp.176 = setgt int %tmp.175, 15		; <bool> [#uses=1]
-	%tmp.177 = cast bool %tmp.176 to int		; <int> [#uses=1]
+	%tmp.174 = getelementptr %struct.macroblock* %tmp.173, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.175 = load i32* %tmp.174		; <i32> [#uses=1]
+	%tmp.176 = icmp sgt i32 %tmp.175, 15		; <i1> [#uses=1]
+	%tmp.177 = zext i1 %tmp.176 to i32		; <i32> [#uses=1]
 	br label %endif.9
 
 endif.9:		; preds = %else.7, %then.10, %then.8
-	%b.4 = phi int [ 1, %then.10 ], [ %tmp.177, %else.7 ], [ 0, %then.8 ]		; <int> [#uses=1]
-	%tmp.179 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%b.4 = phi i32 [ 1, %then.10 ], [ %tmp.177, %else.7 ], [ 0, %then.8 ]		; <i32> [#uses=1]
+	%tmp.179 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.180 = load %struct.macroblock** %tmp.179		; <%struct.macroblock*> [#uses=1]
-	%tmp.181 = cast %struct.macroblock* %tmp.180 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp.182 = setne sbyte* %tmp.181, null		; <bool> [#uses=2]
-	%tmp.183 = cast bool %tmp.182 to int		; <int> [#uses=0]
-	br bool %tmp.182, label %then.11, label %endif.11
+	%tmp.181 = bitcast %struct.macroblock* %tmp.180 to i8*		; <i8*> [#uses=1]
+	%tmp.182 = icmp ne i8* %tmp.181, null		; <i1> [#uses=2]
+	%tmp.183 = zext i1 %tmp.182 to i32		; <i32> [#uses=0]
+	br i1 %tmp.182, label %then.11, label %endif.11
 
 then.11:		; preds = %endif.9
-	%tmp.185 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%tmp.185 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.186 = load %struct.macroblock** %tmp.185		; <%struct.macroblock*> [#uses=1]
-	%tmp.187 = getelementptr %struct.macroblock* %tmp.186, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.188 = load int* %tmp.187		; <int> [#uses=1]
-	%tmp.189 = seteq int %tmp.188, 14		; <bool> [#uses=2]
-	%tmp.190 = cast bool %tmp.189 to int		; <int> [#uses=0]
-	br bool %tmp.189, label %then.12, label %else.8
+	%tmp.187 = getelementptr %struct.macroblock* %tmp.186, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.188 = load i32* %tmp.187		; <i32> [#uses=1]
+	%tmp.189 = icmp eq i32 %tmp.188, 14		; <i1> [#uses=2]
+	%tmp.190 = zext i1 %tmp.189 to i32		; <i32> [#uses=0]
+	br i1 %tmp.189, label %then.12, label %else.8
 
 then.12:		; preds = %then.11
 	br label %endif.11
 
 else.8:		; preds = %then.11
-	%tmp.192 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%tmp.192 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.193 = load %struct.macroblock** %tmp.192		; <%struct.macroblock*> [#uses=1]
-	%tmp.194 = getelementptr %struct.macroblock* %tmp.193, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.195 = load int* %tmp.194		; <int> [#uses=1]
-	%tmp.196 = setgt int %tmp.195, 15		; <bool> [#uses=1]
-	%tmp.197 = cast bool %tmp.196 to int		; <int> [#uses=1]
+	%tmp.194 = getelementptr %struct.macroblock* %tmp.193, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.195 = load i32* %tmp.194		; <i32> [#uses=1]
+	%tmp.196 = icmp sgt i32 %tmp.195, 15		; <i1> [#uses=1]
+	%tmp.197 = zext i1 %tmp.196 to i32		; <i32> [#uses=1]
 	br label %endif.11
 
 endif.11:		; preds = %else.8, %then.12, %endif.9
-	%a.4 = phi int [ 1, %then.12 ], [ %tmp.197, %else.8 ], [ 0, %endif.9 ]		; <int> [#uses=1]
-	%tmp.199 = mul int %b.4, 2		; <int> [#uses=1]
-	%tmp.201 = add int %tmp.199, %a.4		; <int> [#uses=1]
-	%tmp.205 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
-	%tmp.206 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.205, int 0, int 1		; <[4 x %typedef.BiContextType]*> [#uses=1]
-	%tmp.207 = getelementptr [4 x %typedef.BiContextType]* %tmp.206, int 0, int 0		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.209 = cast int %tmp.201 to uint		; <uint> [#uses=1]
-	%tmp.210 = cast uint %tmp.209 to int		; <int> [#uses=1]
-	%tmp.211 = getelementptr %typedef.BiContextType* %tmp.207, int %tmp.210		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.202 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.211 )		; <uint> [#uses=1]
-	%tmp.212 = cast uint %tmp.202 to int		; <int> [#uses=1]
-	%tmp.214 = setne int %tmp.212, 0		; <bool> [#uses=2]
-	%tmp.215 = cast bool %tmp.214 to int		; <int> [#uses=0]
-	br bool %tmp.214, label %then.13, label %endif.8
+	%a.4 = phi i32 [ 1, %then.12 ], [ %tmp.197, %else.8 ], [ 0, %endif.9 ]		; <i32> [#uses=1]
+	%tmp.199 = mul i32 %b.4, 2		; <i32> [#uses=1]
+	%tmp.201 = add i32 %tmp.199, %a.4		; <i32> [#uses=1]
+	%tmp.205 = getelementptr %typedef.TextureInfoContexts* %tmp.4, i32 0, i32 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
+	%tmp.206 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.205, i32 0, i32 1		; <[4 x %typedef.BiContextType]*> [#uses=1]
+	%tmp.207 = getelementptr [4 x %typedef.BiContextType]* %tmp.206, i32 0, i32 0		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.209 = bitcast i32 %tmp.201 to i32		; <i32> [#uses=1]
+	%tmp.210 = bitcast i32 %tmp.209 to i32		; <i32> [#uses=1]
+	%tmp.211 = getelementptr %typedef.BiContextType* %tmp.207, i32 %tmp.210		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.202 = call i32 @biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.211 )		; <i32> [#uses=1]
+	%tmp.212 = bitcast i32 %tmp.202 to i32		; <i32> [#uses=1]
+	%tmp.214 = icmp ne i32 %tmp.212, 0		; <i1> [#uses=2]
+	%tmp.215 = zext i1 %tmp.214 to i32		; <i32> [#uses=0]
+	br i1 %tmp.214, label %then.13, label %endif.8
 
 then.13:		; preds = %endif.11
-	%tmp.217 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.217 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.218 = load %struct.macroblock** %tmp.217		; <%struct.macroblock*> [#uses=1]
-	%tmp.219 = cast %struct.macroblock* %tmp.218 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp.220 = setne sbyte* %tmp.219, null		; <bool> [#uses=2]
-	%tmp.221 = cast bool %tmp.220 to int		; <int> [#uses=0]
-	br bool %tmp.220, label %then.14, label %endif.14
+	%tmp.219 = bitcast %struct.macroblock* %tmp.218 to i8*		; <i8*> [#uses=1]
+	%tmp.220 = icmp ne i8* %tmp.219, null		; <i1> [#uses=2]
+	%tmp.221 = zext i1 %tmp.220 to i32		; <i32> [#uses=0]
+	br i1 %tmp.220, label %then.14, label %endif.14
 
 then.14:		; preds = %then.13
-	%tmp.223 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.223 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.224 = load %struct.macroblock** %tmp.223		; <%struct.macroblock*> [#uses=1]
-	%tmp.225 = getelementptr %struct.macroblock* %tmp.224, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.226 = load int* %tmp.225		; <int> [#uses=1]
-	%tmp.227 = seteq int %tmp.226, 14		; <bool> [#uses=2]
-	%tmp.228 = cast bool %tmp.227 to int		; <int> [#uses=0]
-	br bool %tmp.227, label %then.15, label %else.9
+	%tmp.225 = getelementptr %struct.macroblock* %tmp.224, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.226 = load i32* %tmp.225		; <i32> [#uses=1]
+	%tmp.227 = icmp eq i32 %tmp.226, 14		; <i1> [#uses=2]
+	%tmp.228 = zext i1 %tmp.227 to i32		; <i32> [#uses=0]
+	br i1 %tmp.227, label %then.15, label %else.9
 
 then.15:		; preds = %then.14
 	br label %endif.14
 
 else.9:		; preds = %then.14
-	%tmp.230 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.230 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.231 = load %struct.macroblock** %tmp.230		; <%struct.macroblock*> [#uses=1]
-	%tmp.232 = getelementptr %struct.macroblock* %tmp.231, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.233 = load int* %tmp.232		; <int> [#uses=1]
-	%tmp.234 = setgt int %tmp.233, 15		; <bool> [#uses=2]
-	%tmp.235 = cast bool %tmp.234 to int		; <int> [#uses=0]
-	br bool %tmp.234, label %then.16, label %endif.14
+	%tmp.232 = getelementptr %struct.macroblock* %tmp.231, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.233 = load i32* %tmp.232		; <i32> [#uses=1]
+	%tmp.234 = icmp sgt i32 %tmp.233, 15		; <i1> [#uses=2]
+	%tmp.235 = zext i1 %tmp.234 to i32		; <i32> [#uses=0]
+	br i1 %tmp.234, label %then.16, label %endif.14
 
 then.16:		; preds = %else.9
-	%tmp.237 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3		; <%struct.macroblock**> [#uses=1]
+	%tmp.237 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 3		; <%struct.macroblock**> [#uses=1]
 	%tmp.238 = load %struct.macroblock** %tmp.237		; <%struct.macroblock*> [#uses=1]
-	%tmp.239 = getelementptr %struct.macroblock* %tmp.238, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.240 = load int* %tmp.239		; <int> [#uses=1]
-	%tmp.242 = shr int %tmp.240, ubyte 4		; <int> [#uses=1]
-	%tmp.243 = seteq int %tmp.242, 2		; <bool> [#uses=1]
-	%tmp.244 = cast bool %tmp.243 to int		; <int> [#uses=1]
+	%tmp.239 = getelementptr %struct.macroblock* %tmp.238, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.240 = load i32* %tmp.239		; <i32> [#uses=1]
+	%tmp.242 = ashr i32 %tmp.240, 4		; <i32> [#uses=1]
+	%tmp.243 = icmp eq i32 %tmp.242, 2		; <i1> [#uses=1]
+	%tmp.244 = zext i1 %tmp.243 to i32		; <i32> [#uses=1]
 	br label %endif.14
 
 endif.14:		; preds = %then.16, %else.9, %then.15, %then.13
-	%b.5 = phi int [ 1, %then.15 ], [ %tmp.244, %then.16 ], [ 0, %else.9 ], [ 0, %then.13 ]		; <int> [#uses=1]
-	%tmp.246 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%b.5 = phi i32 [ 1, %then.15 ], [ %tmp.244, %then.16 ], [ 0, %else.9 ], [ 0, %then.13 ]		; <i32> [#uses=1]
+	%tmp.246 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.247 = load %struct.macroblock** %tmp.246		; <%struct.macroblock*> [#uses=1]
-	%tmp.248 = cast %struct.macroblock* %tmp.247 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp.249 = setne sbyte* %tmp.248, null		; <bool> [#uses=2]
-	%tmp.250 = cast bool %tmp.249 to int		; <int> [#uses=0]
-	br bool %tmp.249, label %then.17, label %endif.17
+	%tmp.248 = bitcast %struct.macroblock* %tmp.247 to i8*		; <i8*> [#uses=1]
+	%tmp.249 = icmp ne i8* %tmp.248, null		; <i1> [#uses=2]
+	%tmp.250 = zext i1 %tmp.249 to i32		; <i32> [#uses=0]
+	br i1 %tmp.249, label %then.17, label %endif.17
 
 then.17:		; preds = %endif.14
-	%tmp.252 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%tmp.252 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.253 = load %struct.macroblock** %tmp.252		; <%struct.macroblock*> [#uses=1]
-	%tmp.254 = getelementptr %struct.macroblock* %tmp.253, int 0, uint 5		; <int*> [#uses=1]
-	%tmp.255 = load int* %tmp.254		; <int> [#uses=1]
-	%tmp.256 = seteq int %tmp.255, 14		; <bool> [#uses=2]
-	%tmp.257 = cast bool %tmp.256 to int		; <int> [#uses=0]
-	br bool %tmp.256, label %then.18, label %else.10
+	%tmp.254 = getelementptr %struct.macroblock* %tmp.253, i32 0, i32 5		; <i32*> [#uses=1]
+	%tmp.255 = load i32* %tmp.254		; <i32> [#uses=1]
+	%tmp.256 = icmp eq i32 %tmp.255, 14		; <i1> [#uses=2]
+	%tmp.257 = zext i1 %tmp.256 to i32		; <i32> [#uses=0]
+	br i1 %tmp.256, label %then.18, label %else.10
 
 then.18:		; preds = %then.17
 	br label %endif.17
 
 else.10:		; preds = %then.17
-	%tmp.259 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%tmp.259 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.260 = load %struct.macroblock** %tmp.259		; <%struct.macroblock*> [#uses=1]
-	%tmp.261 = getelementptr %struct.macroblock* %tmp.260, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.262 = load int* %tmp.261		; <int> [#uses=1]
-	%tmp.263 = setgt int %tmp.262, 15		; <bool> [#uses=2]
-	%tmp.264 = cast bool %tmp.263 to int		; <int> [#uses=0]
-	br bool %tmp.263, label %then.19, label %endif.17
+	%tmp.261 = getelementptr %struct.macroblock* %tmp.260, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.262 = load i32* %tmp.261		; <i32> [#uses=1]
+	%tmp.263 = icmp sgt i32 %tmp.262, 15		; <i1> [#uses=2]
+	%tmp.264 = zext i1 %tmp.263 to i32		; <i32> [#uses=0]
+	br i1 %tmp.263, label %then.19, label %endif.17
 
 then.19:		; preds = %else.10
-	%tmp.266 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4		; <%struct.macroblock**> [#uses=1]
+	%tmp.266 = getelementptr %struct.macroblock* %tmp.12, i32 0, i32 4		; <%struct.macroblock**> [#uses=1]
 	%tmp.267 = load %struct.macroblock** %tmp.266		; <%struct.macroblock*> [#uses=1]
-	%tmp.268 = getelementptr %struct.macroblock* %tmp.267, int 0, uint 7		; <int*> [#uses=1]
-	%tmp.269 = load int* %tmp.268		; <int> [#uses=1]
-	%tmp.271 = shr int %tmp.269, ubyte 4		; <int> [#uses=1]
-	%tmp.272 = seteq int %tmp.271, 2		; <bool> [#uses=1]
-	%tmp.273 = cast bool %tmp.272 to int		; <int> [#uses=1]
+	%tmp.268 = getelementptr %struct.macroblock* %tmp.267, i32 0, i32 7		; <i32*> [#uses=1]
+	%tmp.269 = load i32* %tmp.268		; <i32> [#uses=1]
+	%tmp.271 = ashr i32 %tmp.269, 4		; <i32> [#uses=1]
+	%tmp.272 = icmp eq i32 %tmp.271, 2		; <i1> [#uses=1]
+	%tmp.273 = zext i1 %tmp.272 to i32		; <i32> [#uses=1]
 	br label %endif.17
 
 endif.17:		; preds = %then.19, %else.10, %then.18, %endif.14
-	%a.5 = phi int [ 1, %then.18 ], [ %tmp.273, %then.19 ], [ 0, %else.10 ], [ 0, %endif.14 ]		; <int> [#uses=1]
-	%tmp.275 = mul int %b.5, 2		; <int> [#uses=1]
-	%tmp.277 = add int %tmp.275, %a.5		; <int> [#uses=1]
-	%tmp.281 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
-	%tmp.282 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.281, int 0, int 2		; <[4 x %typedef.BiContextType]*> [#uses=1]
-	%tmp.283 = getelementptr [4 x %typedef.BiContextType]* %tmp.282, int 0, int 0		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.285 = cast int %tmp.277 to uint		; <uint> [#uses=1]
-	%tmp.286 = cast uint %tmp.285 to int		; <int> [#uses=1]
-	%tmp.287 = getelementptr %typedef.BiContextType* %tmp.283, int %tmp.286		; <%typedef.BiContextType*> [#uses=1]
-	%tmp.278 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.287 )		; <uint> [#uses=1]
-	%tmp.288 = cast uint %tmp.278 to int		; <int> [#uses=1]
-	%tmp.290 = seteq int %tmp.288, 1		; <bool> [#uses=2]
-	%tmp.291 = cast bool %tmp.290 to int		; <int> [#uses=0]
-	br bool %tmp.290, label %cond_true, label %cond_false
+	%a.5 = phi i32 [ 1, %then.18 ], [ %tmp.273, %then.19 ], [ 0, %else.10 ], [ 0, %endif.14 ]		; <i32> [#uses=1]
+	%tmp.275 = mul i32 %b.5, 2		; <i32> [#uses=1]
+	%tmp.277 = add i32 %tmp.275, %a.5		; <i32> [#uses=1]
+	%tmp.281 = getelementptr %typedef.TextureInfoContexts* %tmp.4, i32 0, i32 2		; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1]
+	%tmp.282 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.281, i32 0, i32 2		; <[4 x %typedef.BiContextType]*> [#uses=1]
+	%tmp.283 = getelementptr [4 x %typedef.BiContextType]* %tmp.282, i32 0, i32 0		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.285 = bitcast i32 %tmp.277 to i32		; <i32> [#uses=1]
+	%tmp.286 = bitcast i32 %tmp.285 to i32		; <i32> [#uses=1]
+	%tmp.287 = getelementptr %typedef.BiContextType* %tmp.283, i32 %tmp.286		; <%typedef.BiContextType*> [#uses=1]
+	%tmp.278 = call i32 @biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.287 )		; <i32> [#uses=1]
+	%tmp.288 = bitcast i32 %tmp.278 to i32		; <i32> [#uses=1]
+	%tmp.290 = icmp eq i32 %tmp.288, 1		; <i1> [#uses=2]
+	%tmp.291 = zext i1 %tmp.290 to i32		; <i32> [#uses=0]
+	br i1 %tmp.290, label %cond_true, label %cond_false
 
 cond_true:		; preds = %endif.17
-	%tmp.293 = add int %cbp.2, 32		; <int> [#uses=1]
+	%tmp.293 = add i32 %cbp.2, 32		; <i32> [#uses=1]
 	br label %cond_continue
 
 cond_false:		; preds = %endif.17
-	%tmp.295 = add int %cbp.2, 16		; <int> [#uses=1]
+	%tmp.295 = add i32 %cbp.2, 16		; <i32> [#uses=1]
 	br label %cond_continue
 
 cond_continue:		; preds = %cond_false, %cond_true
-	%mem_tmp.0 = phi int [ %tmp.293, %cond_true ], [ %tmp.295, %cond_false ]		; <int> [#uses=1]
+	%mem_tmp.0 = phi i32 [ %tmp.293, %cond_true ], [ %tmp.295, %cond_false ]		; <i32> [#uses=1]
 	br label %endif.8
 
 endif.8:		; preds = %cond_continue, %endif.11, %loopexit.0
-	%cbp.3 = phi int [ %mem_tmp.0, %cond_continue ], [ %cbp.2, %endif.11 ], [ %cbp.2, %loopexit.0 ]		; <int> [#uses=2]
-	%tmp.298 = getelementptr %struct.syntaxelement* %se, int 0, uint 1		; <int*> [#uses=1]
-	store int %cbp.3, int* %tmp.298
-	%tmp.301 = seteq int %cbp.3, 0		; <bool> [#uses=2]
-	%tmp.302 = cast bool %tmp.301 to int		; <int> [#uses=0]
-	br bool %tmp.301, label %then.20, label %return
+	%cbp.3 = phi i32 [ %mem_tmp.0, %cond_continue ], [ %cbp.2, %endif.11 ], [ %cbp.2, %loopexit.0 ]		; <i32> [#uses=2]
+	%tmp.298 = getelementptr %struct.syntaxelement* %se, i32 0, i32 1		; <i32*> [#uses=1]
+	store i32 %cbp.3, i32* %tmp.298
+	%tmp.301 = icmp eq i32 %cbp.3, 0		; <i1> [#uses=2]
+	%tmp.302 = zext i1 %tmp.301 to i32		; <i32> [#uses=0]
+	br i1 %tmp.301, label %then.20, label %return
 
 then.20:		; preds = %endif.8
-	store int 0, int* %last_dquant
+	store i32 0, i32* @last_dquant
 	ret void
 
 return:		; preds = %endif.8
 	ret void
 }
 
-declare uint %biari_decode_symbol(%typedef.DecodingEnvironment*, %typedef.BiContextType*)
+declare i32 @biari_decode_symbol(%typedef.DecodingEnvironment*, %typedef.BiContextType*)
 
-declare void %getLuma4x4Neighbour(int, int, int, int, int, %struct.pix_pos*)
+declare void @getLuma4x4Neighbour(i32, i32, i32, i32, i32, %struct.pix_pos*)
diff --git a/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll b/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll
index 6e25d79ecb..2541eb7330 100644
--- a/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll
+++ b/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll
@@ -1,10 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep shl
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep shl
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | notcast
 
 ; This cannot be turned into a sign extending cast!
 
-long %test(long %X) {
-	%Y = shl long %X, ubyte 16
-	%Z = shr long %Y, ubyte 16
-	ret long %Z
+define i64 @test(i64 %X) {
+        %Y = shl i64 %X, 16             ; <i64> [#uses=1]
+        %Z = ashr i64 %Y, 16            ; <i64> [#uses=1]
+        ret i64 %Z
 }
+
diff --git a/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll b/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll
index 3e72a182a0..4506bf0a4e 100644
--- a/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll
+++ b/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll
@@ -1,49 +1,48 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-; END.
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-void %test() {
+define void @test() {
 bb38.i:
-	%varspec.0.i1014 = cast long 123814269237067777 to ulong		; <ulong> [#uses=1]
-	%locspec.0.i1015 = cast int 1 to uint		; <uint> [#uses=2]
-	%tmp51391.i1018 = shr ulong %varspec.0.i1014, ubyte 16		; <ulong> [#uses=1]
-	%tmp51392.i1019 = cast ulong %tmp51391.i1018 to uint		; <uint> [#uses=2]
-	%tmp51392.mask.i1020 = shr uint %tmp51392.i1019, ubyte 29		; <uint> [#uses=1]
-	%tmp7.i1021 = and uint %tmp51392.mask.i1020, 1		; <uint> [#uses=2]
-	%tmp18.i1026 = shr uint %tmp51392.i1019, ubyte 31		; <uint> [#uses=2]
-	%tmp18.i1027 = cast uint %tmp18.i1026 to ubyte		; <ubyte> [#uses=1]
-	br bool false, label %cond_false1148.i1653, label %bb377.i1259
+	%varspec.0.i1014 = bitcast i64 123814269237067777 to i64		; <i64> [#uses=1]
+	%locspec.0.i1015 = bitcast i32 1 to i32		; <i32> [#uses=2]
+	%tmp51391.i1018 = lshr i64 %varspec.0.i1014, 16		; <i64> [#uses=1]
+	%tmp51392.i1019 = trunc i64 %tmp51391.i1018 to i32		; <i32> [#uses=2]
+	%tmp51392.mask.i1020 = lshr i32 %tmp51392.i1019, 29		; <i32> [#uses=1]
+	%tmp7.i1021 = and i32 %tmp51392.mask.i1020, 1		; <i32> [#uses=2]
+	%tmp18.i1026 = lshr i32 %tmp51392.i1019, 31		; <i32> [#uses=2]
+	%tmp18.i1027 = trunc i32 %tmp18.i1026 to i8		; <i8> [#uses=1]
+	br i1 false, label %cond_false1148.i1653, label %bb377.i1259
 
 bb377.i1259:		; preds = %bb38.i
-	br bool false, label %cond_true541.i1317, label %cond_false1148.i1653
+	br i1 false, label %cond_true541.i1317, label %cond_false1148.i1653
 
 cond_true541.i1317:		; preds = %bb377.i1259
-	%tmp545.i1318 = shr uint %locspec.0.i1015, ubyte 10		; <uint> [#uses=1]
-	%tmp550.i1319 = shr uint %locspec.0.i1015, ubyte 4		; <uint> [#uses=1]
-	%tmp550551.i1320 = and uint %tmp550.i1319, 63		; <uint> [#uses=1]
-	%tmp553.i1321 = setlt uint %tmp550551.i1320, 4		; <bool> [#uses=1]
-	%tmp558.i1322 = seteq uint %tmp7.i1021, 0		; <bool> [#uses=1]
-	%bothcond.i1326 = or bool %tmp553.i1321, false		; <bool> [#uses=1]
-	%bothcond1.i1327 = or bool %bothcond.i1326, false		; <bool> [#uses=1]
-	%bothcond2.not.i1328 = or bool %bothcond1.i1327, false		; <bool> [#uses=1]
-	%bothcond3.i1329 = or bool %bothcond2.not.i1328, %tmp558.i1322		; <bool> [#uses=0]
-	br bool false, label %cond_true583.i1333, label %cond_next592.i1337
+	%tmp545.i1318 = lshr i32 %locspec.0.i1015, 10		; <i32> [#uses=1]
+	%tmp550.i1319 = lshr i32 %locspec.0.i1015, 4		; <i32> [#uses=1]
+	%tmp550551.i1320 = and i32 %tmp550.i1319, 63		; <i32> [#uses=1]
+	%tmp553.i1321 = icmp ult i32 %tmp550551.i1320, 4		; <i1> [#uses=1]
+	%tmp558.i1322 = icmp eq i32 %tmp7.i1021, 0		; <i1> [#uses=1]
+	%bothcond.i1326 = or i1 %tmp553.i1321, false		; <i1> [#uses=1]
+	%bothcond1.i1327 = or i1 %bothcond.i1326, false		; <i1> [#uses=1]
+	%bothcond2.not.i1328 = or i1 %bothcond1.i1327, false		; <i1> [#uses=1]
+	%bothcond3.i1329 = or i1 %bothcond2.not.i1328, %tmp558.i1322		; <i1> [#uses=0]
+	br i1 false, label %cond_true583.i1333, label %cond_next592.i1337
 
 cond_true583.i1333:		; preds = %cond_true541.i1317
-	br bool false, label %cond_true586.i1335, label %cond_next592.i1337
+	br i1 false, label %cond_true586.i1335, label %cond_next592.i1337
 
 cond_true586.i1335:		; preds = %cond_true583.i1333
 	br label %cond_true.i
 
 cond_next592.i1337:		; preds = %cond_true583.i1333, %cond_true541.i1317
-	%mask_z.0.i1339 = phi uint [ %tmp18.i1026, %cond_true541.i1317 ], [ 0, %cond_true583.i1333 ]		; <uint> [#uses=0]
-	%tmp594.i1340 = and uint %tmp545.i1318, 15		; <uint> [#uses=0]
+	%mask_z.0.i1339 = phi i32 [ %tmp18.i1026, %cond_true541.i1317 ], [ 0, %cond_true583.i1333 ]		; <i32> [#uses=0]
+	%tmp594.i1340 = and i32 %tmp545.i1318, 15		; <i32> [#uses=0]
 	br label %cond_true.i
 
 cond_false1148.i1653:		; preds = %bb377.i1259, %bb38.i
-	%tmp1150.i1654 = seteq uint %tmp7.i1021, 0		; <bool> [#uses=1]
-	%tmp1160.i1656 = seteq ubyte %tmp18.i1027, 0		; <bool> [#uses=1]
-	%bothcond8.i1658 = or bool %tmp1150.i1654, %tmp1160.i1656		; <bool> [#uses=1]
-	%bothcond9.i1659 = or bool %bothcond8.i1658, false		; <bool> [#uses=0]
+	%tmp1150.i1654 = icmp eq i32 %tmp7.i1021, 0		; <i1> [#uses=1]
+	%tmp1160.i1656 = icmp eq i8 %tmp18.i1027, 0		; <i1> [#uses=1]
+	%bothcond8.i1658 = or i1 %tmp1150.i1654, %tmp1160.i1656		; <i1> [#uses=1]
+	%bothcond9.i1659 = or i1 %bothcond8.i1658, false		; <i1> [#uses=0]
 	br label %cond_true.i
 
 cond_true.i:		; preds = %cond_false1148.i1653, %cond_next592.i1337, %cond_true586.i1335
diff --git a/test/Transforms/InstCombine/2006-05-06-Infloop.ll b/test/Transforms/InstCombine/2006-05-06-Infloop.ll
index 4458d97f93..b1c48ecba7 100644
--- a/test/Transforms/InstCombine/2006-05-06-Infloop.ll
+++ b/test/Transforms/InstCombine/2006-05-06-Infloop.ll
@@ -1,301 +1,296 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-; END.
-
-	%struct.gs_matrix = type { float, int, float, int, float, int, float, int, float, int, float, int }
-	%struct.gx_bitmap = type { ubyte*, int, int, int }
-	%struct.gx_device = type { int, %struct.gx_device_procs*, sbyte*, int, int, float, float, int, ushort, int, int }
-	%struct.gx_device_memory = type { int, %struct.gx_device_procs*, sbyte*, int, int, float, float, int, ushort, int, int, %struct.gs_matrix, int, ubyte*, ubyte**, int (%struct.gx_device_memory*, int, int, int, int, int)*, int, int, ubyte* }
-	%struct.gx_device_procs = type { int (%struct.gx_device*)*, void (%struct.gx_device*, %struct.gs_matrix*)*, int (%struct.gx_device*)*, int (%struct.gx_device*)*, int (%struct.gx_device*)*, uint (%struct.gx_device*, ushort, ushort, ushort)*, int (%struct.gx_device*, uint, ushort*)*, int (%struct.gx_device*, int, int, int, int, uint)*, int (%struct.gx_device*, %struct.gx_bitmap*, int, int, int, int, uint, uint)*, int (%struct.gx_device*, ubyte*, int, int, int, int, int, int, uint, uint)*, int (%struct.gx_device*, ubyte*, int, int, int, int, int, int)*, int (%struct.gx_device*, int, int, int, int, uint)*, int (%struct.gx_device*, int, int, int, int, int, int, uint)*, int (%struct.gx_device*, %struct.gx_bitmap*, int, int, int, int, int, int, uint, uint)* }
-
-implementation   ; Functions:
-
-int %mem_mono_copy_mono(%struct.gx_device* %dev, ubyte* %base, int %sourcex, int %raster, int %x, int %y, int %w, int %h, uint %zero, uint %one) {
+; RUN: llvm-as < %s | opt -instcombine -disable-output
+	%struct.gs_matrix = type { float, i32, float, i32, float, i32, float, i32, float, i32, float, i32 }
+	%struct.gx_bitmap = type { i8*, i32, i32, i32 }
+	%struct.gx_device = type { i32, %struct.gx_device_procs*, i8*, i32, i32, float, float, i32, i16, i32, i32 }
+	%struct.gx_device_memory = type { i32, %struct.gx_device_procs*, i8*, i32, i32, float, float, i32, i16, i32, i32, %struct.gs_matrix, i32, i8*, i8**, i32 (%struct.gx_device_memory*, i32, i32, i32, i32, i32)*, i32, i32, i8* }
+	%struct.gx_device_procs = type { i32 (%struct.gx_device*)*, void (%struct.gx_device*, %struct.gs_matrix*)*, i32 (%struct.gx_device*)*, i32 (%struct.gx_device*)*, i32 (%struct.gx_device*)*, i32 (%struct.gx_device*, i16, i16, i16)*, i32 (%struct.gx_device*, i32, i16*)*, i32 (%struct.gx_device*, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, %struct.gx_bitmap*, i32, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, i8*, i32, i32, i32, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, i8*, i32, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, i32, i32, i32, i32, i32, i32, i32)*, i32 (%struct.gx_device*, %struct.gx_bitmap*, i32, i32, i32, i32, i32, i32, i32, i32)* }
+
+define i32 @mem_mono_copy_mono(%struct.gx_device* %dev, i8* %base, i32 %sourcex, i32 %raster, i32 %x, i32 %y, i32 %w, i32 %h, i32 %zero, i32 %one) {
 entry:
-	%raster = cast int %raster to uint		; <uint> [#uses=3]
-	%tmp = seteq uint %one, %zero		; <bool> [#uses=1]
-	br bool %tmp, label %cond_true, label %cond_next
+	%tmp = icmp eq i32 %one, %zero		; <i1> [#uses=1]
+	br i1 %tmp, label %cond_true, label %cond_next
 
 cond_true:		; preds = %entry
-	%tmp6 = tail call int %mem_mono_fill_rectangle( %struct.gx_device* %dev, int %x, int %y, int %w, int %h, uint %zero )		; <int> [#uses=1]
-	ret int %tmp6
+	%tmp6 = tail call i32 @mem_mono_fill_rectangle( %struct.gx_device* %dev, i32 %x, i32 %y, i32 %w, i32 %h, i32 %zero )		; <i32> [#uses=1]
+	ret i32 %tmp6
 
 cond_next:		; preds = %entry
-	%tmp8 = cast %struct.gx_device* %dev to %struct.gx_device_memory*		; <%struct.gx_device_memory*> [#uses=6]
-	%tmp = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 15		; <int (%struct.gx_device_memory*, int, int, int, int, int)**> [#uses=1]
-	%tmp = load int (%struct.gx_device_memory*, int, int, int, int, int)** %tmp		; <int (%struct.gx_device_memory*, int, int, int, int, int)*> [#uses=2]
-	%tmp9 = seteq int (%struct.gx_device_memory*, int, int, int, int, int)* %tmp, %mem_no_fault_proc		; <bool> [#uses=1]
-	br bool %tmp9, label %cond_next46, label %cond_true10
+	%tmp8 = bitcast %struct.gx_device* %dev to %struct.gx_device_memory*		; <%struct.gx_device_memory*> [#uses=6]
+	%tmp.upgrd.1 = getelementptr %struct.gx_device_memory* %tmp8, i32 0, i32 15		; <i32 (%struct.gx_device_memory*, i32, i32, i32, i32, i32)**> [#uses=1]
+	%tmp.upgrd.2 = load i32 (%struct.gx_device_memory*, i32, i32, i32, i32, i32)** %tmp.upgrd.1		; <i32 (%struct.gx_device_memory*, i32, i32, i32, i32, i32)*> [#uses=2]
+	%tmp9 = icmp eq i32 (%struct.gx_device_memory*, i32, i32, i32, i32, i32)* %tmp.upgrd.2, @mem_no_fault_proc		; <i1> [#uses=1]
+	br i1 %tmp9, label %cond_next46, label %cond_true10
 
 cond_true10:		; preds = %cond_next
-	%tmp16 = add int %x, 7		; <int> [#uses=1]
-	%tmp17 = add int %tmp16, %w		; <int> [#uses=1]
-	%tmp18 = shr int %tmp17, ubyte 3		; <int> [#uses=1]
-	%tmp20 = shr int %x, ubyte 3		; <int> [#uses=2]
-	%tmp21 = sub int %tmp18, %tmp20		; <int> [#uses=1]
-	%tmp27 = tail call int %tmp( %struct.gx_device_memory* %tmp8, int %tmp20, int %y, int %tmp21, int %h, int 1 )		; <int> [#uses=2]
-	%tmp29 = setlt int %tmp27, 0		; <bool> [#uses=1]
-	br bool %tmp29, label %cond_true30, label %cond_next46
+	%tmp16 = add i32 %x, 7		; <i32> [#uses=1]
+	%tmp17 = add i32 %tmp16, %w		; <i32> [#uses=1]
+	%tmp18 = ashr i32 %tmp17, 3		; <i32> [#uses=1]
+	%tmp20 = ashr i32 %x, 3		; <i32> [#uses=2]
+	%tmp21 = sub i32 %tmp18, %tmp20		; <i32> [#uses=1]
+	%tmp27 = tail call i32 %tmp.upgrd.2( %struct.gx_device_memory* %tmp8, i32 %tmp20, i32 %y, i32 %tmp21, i32 %h, i32 1 )		; <i32> [#uses=2]
+	%tmp29 = icmp slt i32 %tmp27, 0		; <i1> [#uses=1]
+	br i1 %tmp29, label %cond_true30, label %cond_next46
 
 cond_true30:		; preds = %cond_true10
-	%tmp41 = tail call int %mem_copy_mono_recover( %struct.gx_device* %dev, ubyte* %base, int %sourcex, int %raster, int %x, int %y, int %w, int %h, uint %zero, uint %one, int %tmp27 )		; <int> [#uses=1]
-	ret int %tmp41
+	%tmp41 = tail call i32 @mem_copy_mono_recover( %struct.gx_device* %dev, i8* %base, i32 %sourcex, i32 %raster, i32 %x, i32 %y, i32 %w, i32 %h, i32 %zero, i32 %one, i32 %tmp27 )		; <i32> [#uses=1]
+	ret i32 %tmp41
 
 cond_next46:		; preds = %cond_true10, %cond_next
-	%tmp48 = setgt int %w, 0		; <bool> [#uses=1]
-	%tmp53 = setgt int %h, 0		; <bool> [#uses=1]
-	%bothcond = and bool %tmp53, %tmp48		; <bool> [#uses=1]
-	br bool %bothcond, label %bb58, label %return
+	%tmp48 = icmp sgt i32 %w, 0		; <i1> [#uses=1]
+	%tmp53 = icmp sgt i32 %h, 0		; <i1> [#uses=1]
+	%bothcond = and i1 %tmp53, %tmp48		; <i1> [#uses=1]
+	br i1 %bothcond, label %bb58, label %return
 
 bb58:		; preds = %cond_next46
-	%tmp60 = setlt int %x, 0		; <bool> [#uses=1]
-	br bool %tmp60, label %return, label %cond_next63
+	%tmp60 = icmp slt i32 %x, 0		; <i1> [#uses=1]
+	br i1 %tmp60, label %return, label %cond_next63
 
 cond_next63:		; preds = %bb58
-	%tmp65 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 3		; <int*> [#uses=1]
-	%tmp66 = load int* %tmp65		; <int> [#uses=1]
-	%tmp68 = sub int %tmp66, %w		; <int> [#uses=1]
-	%tmp70 = setlt int %tmp68, %x		; <bool> [#uses=1]
-	%tmp75 = setlt int %y, 0		; <bool> [#uses=1]
-	%bothcond1 = or bool %tmp70, %tmp75		; <bool> [#uses=1]
-	br bool %bothcond1, label %return, label %cond_next78
+	%tmp65 = getelementptr %struct.gx_device_memory* %tmp8, i32 0, i32 3		; <i32*> [#uses=1]
+	%tmp66 = load i32* %tmp65		; <i32> [#uses=1]
+	%tmp68 = sub i32 %tmp66, %w		; <i32> [#uses=1]
+	%tmp70 = icmp slt i32 %tmp68, %x		; <i1> [#uses=1]
+	%tmp75 = icmp slt i32 %y, 0		; <i1> [#uses=1]
+	%bothcond1 = or i1 %tmp70, %tmp75		; <i1> [#uses=1]
+	br i1 %bothcond1, label %return, label %cond_next78
 
 cond_next78:		; preds = %cond_next63
-	%tmp80 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 4		; <int*> [#uses=1]
-	%tmp81 = load int* %tmp80		; <int> [#uses=1]
-	%tmp83 = sub int %tmp81, %h		; <int> [#uses=1]
-	%tmp85 = setlt int %tmp83, %y		; <bool> [#uses=1]
-	br bool %tmp85, label %return, label %bb91
+	%tmp80 = getelementptr %struct.gx_device_memory* %tmp8, i32 0, i32 4		; <i32*> [#uses=1]
+	%tmp81 = load i32* %tmp80		; <i32> [#uses=1]
+	%tmp83 = sub i32 %tmp81, %h		; <i32> [#uses=1]
+	%tmp85 = icmp slt i32 %tmp83, %y		; <i1> [#uses=1]
+	br i1 %tmp85, label %return, label %bb91
 
 bb91:		; preds = %cond_next78
-	%tmp93 = shr int %x, ubyte 3		; <int> [#uses=4]
-	%tmp = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 14		; <ubyte***> [#uses=1]
-	%tmp = load ubyte*** %tmp		; <ubyte**> [#uses=1]
-	%tmp96 = getelementptr ubyte** %tmp, int %y		; <ubyte**> [#uses=4]
-	%tmp98 = load ubyte** %tmp96		; <ubyte*> [#uses=1]
-	%tmp100 = getelementptr ubyte* %tmp98, int %tmp93		; <ubyte*> [#uses=3]
-	%tmp102 = shr int %sourcex, ubyte 3		; <int> [#uses=3]
-	%tmp106 = and int %sourcex, 7		; <int> [#uses=1]
-	%tmp107 = sub int 8, %tmp106		; <int> [#uses=4]
-	%tmp109 = and int %x, 7		; <int> [#uses=3]
-	%tmp110 = sub int 8, %tmp109		; <int> [#uses=8]
-	%tmp112 = sub int 8, %tmp110		; <int> [#uses=1]
-	%tmp112 = cast int %tmp112 to ubyte		; <ubyte> [#uses=1]
-	%tmp113464 = shr uint 255, ubyte %tmp112		; <uint> [#uses=4]
-	%tmp116 = setgt int %tmp110, %w		; <bool> [#uses=1]
-	%tmp132 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 16		; <int*> [#uses=2]
-	br bool %tmp116, label %cond_true117, label %cond_false123
+	%tmp93 = ashr i32 %x, 3		; <i32> [#uses=4]
+	%tmp.upgrd.3 = getelementptr %struct.gx_device_memory* %tmp8, i32 0, i32 14		; <i8***> [#uses=1]
+	%tmp.upgrd.4 = load i8*** %tmp.upgrd.3		; <i8**> [#uses=1]
+	%tmp96 = getelementptr i8** %tmp.upgrd.4, i32 %y		; <i8**> [#uses=4]
+	%tmp98 = load i8** %tmp96		; <i8*> [#uses=1]
+	%tmp100 = getelementptr i8* %tmp98, i32 %tmp93		; <i8*> [#uses=3]
+	%tmp102 = ashr i32 %sourcex, 3		; <i32> [#uses=3]
+	%tmp106 = and i32 %sourcex, 7		; <i32> [#uses=1]
+	%tmp107 = sub i32 8, %tmp106		; <i32> [#uses=4]
+	%tmp109 = and i32 %x, 7		; <i32> [#uses=3]
+	%tmp110 = sub i32 8, %tmp109		; <i32> [#uses=8]
+	%tmp112 = sub i32 8, %tmp110		; <i32> [#uses=1]
+	%tmp112.upgrd.5 = trunc i32 %tmp112 to i8		; <i8> [#uses=1]
+	%shift.upgrd.6 = zext i8 %tmp112.upgrd.5 to i32		; <i32> [#uses=1]
+	%tmp113464 = lshr i32 255, %shift.upgrd.6		; <i32> [#uses=4]
+	%tmp116 = icmp sgt i32 %tmp110, %w		; <i1> [#uses=1]
+	%tmp132 = getelementptr %struct.gx_device_memory* %tmp8, i32 0, i32 16		; <i32*> [#uses=2]
+	br i1 %tmp116, label %cond_true117, label %cond_false123
 
 cond_true117:		; preds = %bb91
-	%tmp119 = cast int %w to ubyte		; <ubyte> [#uses=1]
-	%tmp120 = shr uint %tmp113464, ubyte %tmp119		; <uint> [#uses=1]
-	%tmp122 = sub uint %tmp113464, %tmp120		; <uint> [#uses=2]
-	%tmp13315 = load int* %tmp132		; <int> [#uses=1]
-	%tmp13416 = seteq int %tmp13315, 0		; <bool> [#uses=1]
-	br bool %tmp13416, label %cond_next151, label %cond_true135
+	%tmp119 = trunc i32 %w to i8		; <i8> [#uses=1]
+	%shift.upgrd.7 = zext i8 %tmp119 to i32		; <i32> [#uses=1]
+	%tmp120 = lshr i32 %tmp113464, %shift.upgrd.7		; <i32> [#uses=1]
+	%tmp122 = sub i32 %tmp113464, %tmp120		; <i32> [#uses=2]
+	%tmp13315 = load i32* %tmp132		; <i32> [#uses=1]
+	%tmp13416 = icmp eq i32 %tmp13315, 0		; <i1> [#uses=1]
+	br i1 %tmp13416, label %cond_next151, label %cond_true135
 
 cond_false123:		; preds = %bb91
-	%tmp126 = sub int %w, %tmp110		; <int> [#uses=1]
-	%tmp126 = cast int %tmp126 to ubyte		; <ubyte> [#uses=1]
-	%tmp127 = and ubyte %tmp126, 7		; <ubyte> [#uses=1]
-	%tmp128 = shr uint 255, ubyte %tmp127		; <uint> [#uses=1]
-	%tmp1295 = sub uint 255, %tmp128		; <uint> [#uses=2]
-	%tmp133 = load int* %tmp132		; <int> [#uses=1]
-	%tmp134 = seteq int %tmp133, 0		; <bool> [#uses=1]
-	br bool %tmp134, label %cond_next151, label %cond_true135
+	%tmp126 = sub i32 %w, %tmp110		; <i32> [#uses=1]
+	%tmp126.upgrd.8 = trunc i32 %tmp126 to i8		; <i8> [#uses=1]
+	%tmp127 = and i8 %tmp126.upgrd.8, 7		; <i8> [#uses=1]
+	%shift.upgrd.9 = zext i8 %tmp127 to i32		; <i32> [#uses=1]
+	%tmp128 = lshr i32 255, %shift.upgrd.9		; <i32> [#uses=1]
+	%tmp1295 = sub i32 255, %tmp128		; <i32> [#uses=2]
+	%tmp133 = load i32* %tmp132		; <i32> [#uses=1]
+	%tmp134 = icmp eq i32 %tmp133, 0		; <i1> [#uses=1]
+	br i1 %tmp134, label %cond_next151, label %cond_true135
 
 cond_true135:		; preds = %cond_false123, %cond_true117
-	%rmask.0.0 = phi uint [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ]		; <uint> [#uses=2]
-	%mask.1.0 = phi uint [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ]		; <uint> [#uses=2]
-	%not.tmp137 = setne uint %zero, 4294967295		; <bool> [#uses=1]
-	%tmp140 = cast bool %not.tmp137 to uint		; <uint> [#uses=1]
-	%zero_addr.0 = xor uint %tmp140, %zero		; <uint> [#uses=2]
-	%tmp144 = seteq uint %one, 4294967295		; <bool> [#uses=1]
-	br bool %tmp144, label %cond_next151, label %cond_true145
+	%rmask.0.0 = phi i32 [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ]		; <i32> [#uses=2]
+	%mask.1.0 = phi i32 [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ]		; <i32> [#uses=2]
+	%not.tmp137 = icmp ne i32 %zero, -1		; <i1> [#uses=1]
+	%tmp140 = zext i1 %not.tmp137 to i32		; <i32> [#uses=1]
+	%zero_addr.0 = xor i32 %tmp140, %zero		; <i32> [#uses=2]
+	%tmp144 = icmp eq i32 %one, -1		; <i1> [#uses=1]
+	br i1 %tmp144, label %cond_next151, label %cond_true145
 
 cond_true145:		; preds = %cond_true135
-	%tmp147 = xor uint %one, 1		; <uint> [#uses=1]
+	%tmp147 = xor i32 %one, 1		; <i32> [#uses=1]
 	br label %cond_next151
 
 cond_next151:		; preds = %cond_true145, %cond_true135, %cond_false123, %cond_true117
-	%rmask.0.1 = phi uint [ %rmask.0.0, %cond_true145 ], [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ], [ %rmask.0.0, %cond_true135 ]		; <uint> [#uses=4]
-	%mask.1.1 = phi uint [ %mask.1.0, %cond_true145 ], [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ], [ %mask.1.0, %cond_true135 ]		; <uint> [#uses=4]
-	%one_addr.0 = phi uint [ %tmp147, %cond_true145 ], [ %one, %cond_true117 ], [ %one, %cond_false123 ], [ %one, %cond_true135 ]		; <uint> [#uses=2]
-	%zero_addr.1 = phi uint [ %zero_addr.0, %cond_true145 ], [ %zero, %cond_true117 ], [ %zero, %cond_false123 ], [ %zero_addr.0, %cond_true135 ]		; <uint> [#uses=2]
-	%tmp153 = seteq uint %zero_addr.1, 1		; <bool> [#uses=2]
-	%tmp158 = seteq uint %one_addr.0, 0		; <bool> [#uses=2]
-	%bothcond2 = or bool %tmp153, %tmp158		; <bool> [#uses=1]
-	%iftmp.35.0 = select bool %bothcond2, uint 4294967295, uint 0		; <uint> [#uses=8]
-	%tmp167 = seteq uint %zero_addr.1, 0		; <bool> [#uses=1]
-	%bothcond3 = or bool %tmp167, %tmp158		; <bool> [#uses=1]
-	%iftmp.36.0 = select bool %bothcond3, uint 0, uint 4294967295		; <uint> [#uses=4]
-	%tmp186 = seteq uint %one_addr.0, 1		; <bool> [#uses=1]
-	%bothcond4 = or bool %tmp153, %tmp186		; <bool> [#uses=1]
-	%iftmp.37.0 = select bool %bothcond4, uint 4294967295, uint 0		; <uint> [#uses=6]
-	%tmp196 = seteq int %tmp107, %tmp110		; <bool> [#uses=1]
-	br bool %tmp196, label %cond_true197, label %cond_false299
+	%rmask.0.1 = phi i32 [ %rmask.0.0, %cond_true145 ], [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ], [ %rmask.0.0, %cond_true135 ]		; <i32> [#uses=4]
+	%mask.1.1 = phi i32 [ %mask.1.0, %cond_true145 ], [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ], [ %mask.1.0, %cond_true135 ]		; <i32> [#uses=4]
+	%one_addr.0 = phi i32 [ %tmp147, %cond_true145 ], [ %one, %cond_true117 ], [ %one, %cond_false123 ], [ %one, %cond_true135 ]		; <i32> [#uses=2]
+	%zero_addr.1 = phi i32 [ %zero_addr.0, %cond_true145 ], [ %zero, %cond_true117 ], [ %zero, %cond_false123 ], [ %zero_addr.0, %cond_true135 ]		; <i32> [#uses=2]
+	%tmp153 = icmp eq i32 %zero_addr.1, 1		; <i1> [#uses=2]
+	%tmp158 = icmp eq i32 %one_addr.0, 0		; <i1> [#uses=2]
+	%bothcond2 = or i1 %tmp153, %tmp158		; <i1> [#uses=1]
+	%iftmp.35.0 = select i1 %bothcond2, i32 -1, i32 0		; <i32> [#uses=9]
+	%tmp167 = icmp eq i32 %zero_addr.1, 0		; <i1> [#uses=1]
+	%bothcond3 = or i1 %tmp167, %tmp158		; <i1> [#uses=1]
+	%iftmp.36.0 = select i1 %bothcond3, i32 0, i32 -1		; <i32> [#uses=4]
+	%tmp186 = icmp eq i32 %one_addr.0, 1		; <i1> [#uses=1]
+	%bothcond4 = or i1 %tmp153, %tmp186		; <i1> [#uses=1]
+	%iftmp.37.0 = select i1 %bothcond4, i32 -1, i32 0		; <i32> [#uses=6]
+	%tmp196 = icmp eq i32 %tmp107, %tmp110		; <i1> [#uses=1]
+	br i1 %tmp196, label %cond_true197, label %cond_false299
 
 cond_true197:		; preds = %cond_next151
-	%tmp29222 = add int %h, -1		; <int> [#uses=3]
-	%tmp29424 = setlt int %tmp29222, 0		; <bool> [#uses=1]
-	br bool %tmp29424, label %return, label %cond_true295.preheader
+	%tmp29222 = add i32 %h, -1		; <i32> [#uses=3]
+	%tmp29424 = icmp slt i32 %tmp29222, 0		; <i1> [#uses=1]
+	br i1 %tmp29424, label %return, label %cond_true295.preheader
 
 cond_true249.preheader:		; preds = %cond_true295
 	br label %cond_true249
 
 cond_true249:		; preds = %cond_true249, %cond_true249.preheader
-	%indvar = phi uint [ 0, %cond_true249.preheader ], [ %indvar.next, %cond_true249 ]		; <uint> [#uses=2]
-	%optr.3.2 = phi ubyte* [ %tmp232, %cond_true249 ], [ %dest.1.0, %cond_true249.preheader ]		; <ubyte*> [#uses=1]
-	%bptr.3.2 = phi ubyte* [ %tmp226, %cond_true249 ], [ %line.1.0, %cond_true249.preheader ]		; <ubyte*> [#uses=1]
-	%tmp. = add int %tmp109, %w		; <int> [#uses=1]
-	%indvar = cast uint %indvar to int		; <int> [#uses=1]
-	%tmp.58 = mul int %indvar, -8		; <int> [#uses=1]
-	%tmp.57 = add int %tmp., -16		; <int> [#uses=1]
-	%tmp246.2 = add int %tmp.58, %tmp.57		; <int> [#uses=1]
-	%tmp225 = cast ubyte* %bptr.3.2 to uint		; <uint> [#uses=1]
-	%tmp226 = add uint %tmp225, 1		; <uint> [#uses=1]
-	%tmp226 = cast uint %tmp226 to ubyte*		; <ubyte*> [#uses=3]
-	%tmp228 = load ubyte* %tmp226		; <ubyte> [#uses=1]
-	%tmp228 = cast ubyte %tmp228 to uint		; <uint> [#uses=1]
-	%tmp230 = xor uint %tmp228, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp231 = cast ubyte* %optr.3.2 to uint		; <uint> [#uses=1]
-	%tmp232 = add uint %tmp231, 1		; <uint> [#uses=1]
-	%tmp232 = cast uint %tmp232 to ubyte*		; <ubyte*> [#uses=4]
-	%tmp235 = or uint %tmp230, %iftmp.36.0		; <uint> [#uses=1]
-	%tmp235 = cast uint %tmp235 to ubyte		; <ubyte> [#uses=1]
-	%tmp237 = load ubyte* %tmp232		; <ubyte> [#uses=1]
-	%tmp238 = and ubyte %tmp235, %tmp237		; <ubyte> [#uses=1]
-	%tmp241 = and uint %tmp230, %iftmp.37.0		; <uint> [#uses=1]
-	%tmp241 = cast uint %tmp241 to ubyte		; <ubyte> [#uses=1]
-	%tmp242 = or ubyte %tmp238, %tmp241		; <ubyte> [#uses=1]
-	store ubyte %tmp242, ubyte* %tmp232
-	%tmp24629 = add int %tmp246.2, -8		; <int> [#uses=2]
-	%tmp24831 = setlt int %tmp24629, 0		; <bool> [#uses=1]
-	%indvar.next = add uint %indvar, 1		; <uint> [#uses=1]
-	br bool %tmp24831, label %bb252.loopexit, label %cond_true249
+	%indvar = phi i32 [ 0, %cond_true249.preheader ], [ %indvar.next, %cond_true249 ]		; <i32> [#uses=3]
+	%optr.3.2 = phi i8* [ %tmp232.upgrd.12, %cond_true249 ], [ %dest.1.0, %cond_true249.preheader ]		; <i8*> [#uses=1]
+	%bptr.3.2 = phi i8* [ %tmp226.upgrd.10, %cond_true249 ], [ %line.1.0, %cond_true249.preheader ]		; <i8*> [#uses=1]
+	%tmp. = add i32 %tmp109, %w		; <i32> [#uses=1]
+	%tmp.58 = mul i32 %indvar, -8		; <i32> [#uses=1]
+	%tmp.57 = add i32 %tmp., -16		; <i32> [#uses=1]
+	%tmp246.2 = add i32 %tmp.58, %tmp.57		; <i32> [#uses=1]
+	%tmp225 = ptrtoint i8* %bptr.3.2 to i32		; <i32> [#uses=1]
+	%tmp226 = add i32 %tmp225, 1		; <i32> [#uses=1]
+	%tmp226.upgrd.10 = inttoptr i32 %tmp226 to i8*		; <i8*> [#uses=3]
+	%tmp228 = load i8* %tmp226.upgrd.10		; <i8> [#uses=1]
+	%tmp228.upgrd.11 = zext i8 %tmp228 to i32		; <i32> [#uses=1]
+	%tmp230 = xor i32 %tmp228.upgrd.11, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp231 = ptrtoint i8* %optr.3.2 to i32		; <i32> [#uses=1]
+	%tmp232 = add i32 %tmp231, 1		; <i32> [#uses=1]
+	%tmp232.upgrd.12 = inttoptr i32 %tmp232 to i8*		; <i8*> [#uses=4]
+	%tmp235 = or i32 %tmp230, %iftmp.36.0		; <i32> [#uses=1]
+	%tmp235.upgrd.13 = trunc i32 %tmp235 to i8		; <i8> [#uses=1]
+	%tmp237 = load i8* %tmp232.upgrd.12		; <i8> [#uses=1]
+	%tmp238 = and i8 %tmp235.upgrd.13, %tmp237		; <i8> [#uses=1]
+	%tmp241 = and i32 %tmp230, %iftmp.37.0		; <i32> [#uses=1]
+	%tmp241.upgrd.14 = trunc i32 %tmp241 to i8		; <i8> [#uses=1]
+	%tmp242 = or i8 %tmp238, %tmp241.upgrd.14		; <i8> [#uses=1]
+	store i8 %tmp242, i8* %tmp232.upgrd.12
+	%tmp24629 = add i32 %tmp246.2, -8		; <i32> [#uses=2]
+	%tmp24831 = icmp slt i32 %tmp24629, 0		; <i1> [#uses=1]
+	%indvar.next = add i32 %indvar, 1		; <i32> [#uses=1]
+	br i1 %tmp24831, label %bb252.loopexit, label %cond_true249
 
 bb252.loopexit:		; preds = %cond_true249
 	br label %bb252
 
 bb252:		; preds = %cond_true295, %bb252.loopexit
-	%optr.3.3 = phi ubyte* [ %dest.1.0, %cond_true295 ], [ %tmp232, %bb252.loopexit ]		; <ubyte*> [#uses=1]
-	%bptr.3.3 = phi ubyte* [ %line.1.0, %cond_true295 ], [ %tmp226, %bb252.loopexit ]		; <ubyte*> [#uses=1]
-	%tmp246.3 = phi int [ %tmp246, %cond_true295 ], [ %tmp24629, %bb252.loopexit ]		; <int> [#uses=1]
-	%tmp254 = setgt int %tmp246.3, -8		; <bool> [#uses=1]
-	br bool %tmp254, label %cond_true255, label %cond_next280
+	%optr.3.3 = phi i8* [ %dest.1.0, %cond_true295 ], [ %tmp232.upgrd.12, %bb252.loopexit ]		; <i8*> [#uses=1]
+	%bptr.3.3 = phi i8* [ %line.1.0, %cond_true295 ], [ %tmp226.upgrd.10, %bb252.loopexit ]		; <i8*> [#uses=1]
+	%tmp246.3 = phi i32 [ %tmp246, %cond_true295 ], [ %tmp24629, %bb252.loopexit ]		; <i32> [#uses=1]
+	%tmp254 = icmp sgt i32 %tmp246.3, -8		; <i1> [#uses=1]
+	br i1 %tmp254, label %cond_true255, label %cond_next280
 
 cond_true255:		; preds = %bb252
-	%tmp256 = cast ubyte* %bptr.3.3 to uint		; <uint> [#uses=1]
-	%tmp257 = add uint %tmp256, 1		; <uint> [#uses=1]
-	%tmp257 = cast uint %tmp257 to ubyte*		; <ubyte*> [#uses=1]
-	%tmp259 = load ubyte* %tmp257		; <ubyte> [#uses=1]
-	%tmp259 = cast ubyte %tmp259 to uint		; <uint> [#uses=1]
-	%tmp261 = xor uint %tmp259, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp262 = cast ubyte* %optr.3.3 to uint		; <uint> [#uses=1]
-	%tmp263 = add uint %tmp262, 1		; <uint> [#uses=1]
-	%tmp263 = cast uint %tmp263 to ubyte*		; <ubyte*> [#uses=2]
-	%tmp265 = cast uint %tmp261 to ubyte		; <ubyte> [#uses=1]
-	%tmp268 = or ubyte %tmp266, %tmp265		; <ubyte> [#uses=1]
-	%tmp270 = load ubyte* %tmp263		; <ubyte> [#uses=1]
-	%tmp271 = and ubyte %tmp268, %tmp270		; <ubyte> [#uses=1]
-	%tmp276 = and uint %tmp274, %tmp261		; <uint> [#uses=1]
-	%tmp276 = cast uint %tmp276 to ubyte		; <ubyte> [#uses=1]
-	%tmp277 = or ubyte %tmp271, %tmp276		; <ubyte> [#uses=1]
-	store ubyte %tmp277, ubyte* %tmp263
+	%tmp256 = ptrtoint i8* %bptr.3.3 to i32		; <i32> [#uses=1]
+	%tmp257 = add i32 %tmp256, 1		; <i32> [#uses=1]
+	%tmp257.upgrd.15 = inttoptr i32 %tmp257 to i8*		; <i8*> [#uses=1]
+	%tmp259 = load i8* %tmp257.upgrd.15		; <i8> [#uses=1]
+	%tmp259.upgrd.16 = zext i8 %tmp259 to i32		; <i32> [#uses=1]
+	%tmp261 = xor i32 %tmp259.upgrd.16, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp262 = ptrtoint i8* %optr.3.3 to i32		; <i32> [#uses=1]
+	%tmp263 = add i32 %tmp262, 1		; <i32> [#uses=1]
+	%tmp263.upgrd.17 = inttoptr i32 %tmp263 to i8*		; <i8*> [#uses=2]
+	%tmp265 = trunc i32 %tmp261 to i8		; <i8> [#uses=1]
+	%tmp268 = or i8 %tmp266, %tmp265		; <i8> [#uses=1]
+	%tmp270 = load i8* %tmp263.upgrd.17		; <i8> [#uses=1]
+	%tmp271 = and i8 %tmp268, %tmp270		; <i8> [#uses=1]
+	%tmp276 = and i32 %tmp274, %tmp261		; <i32> [#uses=1]
+	%tmp276.upgrd.18 = trunc i32 %tmp276 to i8		; <i8> [#uses=1]
+	%tmp277 = or i8 %tmp271, %tmp276.upgrd.18		; <i8> [#uses=1]
+	store i8 %tmp277, i8* %tmp263.upgrd.17
 	br label %cond_next280
 
 cond_next280:		; preds = %cond_true255, %bb252
-	%tmp281 = cast ubyte** %dest_line.1.0 to uint		; <uint> [#uses=1]
-	%tmp282 = add uint %tmp281, 4		; <uint> [#uses=1]
-	%tmp282 = cast uint %tmp282 to ubyte**		; <ubyte**> [#uses=2]
-	%tmp284 = load ubyte** %tmp282		; <ubyte*> [#uses=1]
-	%tmp286 = getelementptr ubyte* %tmp284, int %tmp93		; <ubyte*> [#uses=1]
-	%tmp292 = add int %tmp292.0, -1		; <int> [#uses=1]
-	%tmp294 = setlt int %tmp292, 0		; <bool> [#uses=1]
-	%indvar.next61 = add uint %indvar60, 1		; <uint> [#uses=1]
-	br bool %tmp294, label %return.loopexit, label %cond_true295
+	%tmp281 = ptrtoint i8** %dest_line.1.0 to i32		; <i32> [#uses=1]
+	%tmp282 = add i32 %tmp281, 4		; <i32> [#uses=1]
+	%tmp282.upgrd.19 = inttoptr i32 %tmp282 to i8**		; <i8**> [#uses=2]
+	%tmp284 = load i8** %tmp282.upgrd.19		; <i8*> [#uses=1]
+	%tmp286 = getelementptr i8* %tmp284, i32 %tmp93		; <i8*> [#uses=1]
+	%tmp292 = add i32 %tmp292.0, -1		; <i32> [#uses=1]
+	%tmp294 = icmp slt i32 %tmp292, 0		; <i1> [#uses=1]
+	%indvar.next61 = add i32 %indvar60, 1		; <i32> [#uses=1]
+	br i1 %tmp294, label %return.loopexit, label %cond_true295
 
 cond_true295.preheader:		; preds = %cond_true197
-	%tmp200 = sub int %w, %tmp110		; <int> [#uses=1]
-	%tmp209 = cast uint %mask.1.1 to ubyte		; <ubyte> [#uses=1]
-	%tmp209not = xor ubyte %tmp209, 255		; <ubyte> [#uses=1]
-	%tmp212 = cast uint %iftmp.36.0 to ubyte		; <ubyte> [#uses=2]
-	%tmp211 = or ubyte %tmp212, %tmp209not		; <ubyte> [#uses=2]
-	%tmp219 = and uint %iftmp.37.0, %mask.1.1		; <uint> [#uses=2]
-	%tmp246 = add int %tmp200, -8		; <int> [#uses=3]
-	%tmp248 = setlt int %tmp246, 0		; <bool> [#uses=1]
-	%tmp264 = cast uint %rmask.0.1 to ubyte		; <ubyte> [#uses=1]
-	%tmp264not = xor ubyte %tmp264, 255		; <ubyte> [#uses=1]
-	%tmp266 = or ubyte %tmp212, %tmp264not		; <ubyte> [#uses=2]
-	%tmp274 = and uint %iftmp.37.0, %rmask.0.1		; <uint> [#uses=2]
-	br bool %tmp248, label %cond_true295.preheader.split.us, label %cond_true295.preheader.split
+	%tmp200 = sub i32 %w, %tmp110		; <i32> [#uses=1]
+	%tmp209 = trunc i32 %mask.1.1 to i8		; <i8> [#uses=1]
+	%tmp209not = xor i8 %tmp209, -1		; <i8> [#uses=1]
+	%tmp212 = trunc i32 %iftmp.36.0 to i8		; <i8> [#uses=2]
+	%tmp211 = or i8 %tmp212, %tmp209not		; <i8> [#uses=2]
+	%tmp219 = and i32 %iftmp.37.0, %mask.1.1		; <i32> [#uses=2]
+	%tmp246 = add i32 %tmp200, -8		; <i32> [#uses=3]
+	%tmp248 = icmp slt i32 %tmp246, 0		; <i1> [#uses=1]
+	%tmp264 = trunc i32 %rmask.0.1 to i8		; <i8> [#uses=1]
+	%tmp264not = xor i8 %tmp264, -1		; <i8> [#uses=1]
+	%tmp266 = or i8 %tmp212, %tmp264not		; <i8> [#uses=2]
+	%tmp274 = and i32 %iftmp.37.0, %rmask.0.1		; <i32> [#uses=2]
+	br i1 %tmp248, label %cond_true295.preheader.split.us, label %cond_true295.preheader.split
 
 cond_true295.preheader.split.us:		; preds = %cond_true295.preheader
 	br label %cond_true295.us
 
 cond_true295.us:		; preds = %cond_next280.us, %cond_true295.preheader.split.us
-	%indvar86 = phi uint [ 0, %cond_true295.preheader.split.us ], [ %indvar.next87, %cond_next280.us ]		; <uint> [#uses=3]
-	%dest.1.0.us = phi ubyte* [ %tmp286.us, %cond_next280.us ], [ %tmp100, %cond_true295.preheader.split.us ]		; <ubyte*> [#uses=3]
-	%dest_line.1.0.us = phi ubyte** [ %tmp282.us, %cond_next280.us ], [ %tmp96, %cond_true295.preheader.split.us ]		; <ubyte**> [#uses=1]
-	%tmp.89 = sub uint 0, %indvar86		; <uint> [#uses=1]
-	%tmp.89 = cast uint %tmp.89 to int		; <int> [#uses=1]
-	%tmp292.0.us = add int %tmp.89, %tmp29222		; <int> [#uses=1]
-	%tmp.91 = mul uint %indvar86, %raster		; <uint> [#uses=1]
-	%tmp.91 = cast uint %tmp.91 to int		; <int> [#uses=1]
-	%tmp104.sum101 = add int %tmp102, %tmp.91		; <int> [#uses=1]
-	%line.1.0.us = getelementptr ubyte* %base, int %tmp104.sum101		; <ubyte*> [#uses=2]
-	%tmp.us = load ubyte* %line.1.0.us		; <ubyte> [#uses=1]
-	%tmp206.us = cast ubyte %tmp.us to uint		; <uint> [#uses=1]
-	%tmp208.us = xor uint %tmp206.us, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp210.us = cast uint %tmp208.us to ubyte		; <ubyte> [#uses=1]
-	%tmp213.us = or ubyte %tmp211, %tmp210.us		; <ubyte> [#uses=1]
-	%tmp215.us = load ubyte* %dest.1.0.us		; <ubyte> [#uses=1]
-	%tmp216.us = and ubyte %tmp213.us, %tmp215.us		; <ubyte> [#uses=1]
-	%tmp221.us = and uint %tmp219, %tmp208.us		; <uint> [#uses=1]
-	%tmp221.us = cast uint %tmp221.us to ubyte		; <ubyte> [#uses=1]
-	%tmp222.us = or ubyte %tmp216.us, %tmp221.us		; <ubyte> [#uses=1]
-	store ubyte %tmp222.us, ubyte* %dest.1.0.us
-	br bool true, label %bb252.us, label %cond_true249.preheader.us
+	%indvar86 = phi i32 [ 0, %cond_true295.preheader.split.us ], [ %indvar.next87, %cond_next280.us ]		; <i32> [#uses=3]
+	%dest.1.0.us = phi i8* [ %tmp286.us, %cond_next280.us ], [ %tmp100, %cond_true295.preheader.split.us ]		; <i8*> [#uses=3]
+	%dest_line.1.0.us = phi i8** [ %tmp282.us.upgrd.21, %cond_next280.us ], [ %tmp96, %cond_true295.preheader.split.us ]		; <i8**> [#uses=1]
+	%tmp.89 = sub i32 0, %indvar86		; <i32> [#uses=2]
+	%tmp292.0.us = add i32 %tmp.89, %tmp29222		; <i32> [#uses=1]
+	%tmp.91 = mul i32 %indvar86, %raster		; <i32> [#uses=2]
+	%tmp104.sum101 = add i32 %tmp102, %tmp.91		; <i32> [#uses=1]
+	%line.1.0.us = getelementptr i8* %base, i32 %tmp104.sum101		; <i8*> [#uses=2]
+	%tmp.us = load i8* %line.1.0.us		; <i8> [#uses=1]
+	%tmp206.us = zext i8 %tmp.us to i32		; <i32> [#uses=1]
+	%tmp208.us = xor i32 %tmp206.us, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp210.us = trunc i32 %tmp208.us to i8		; <i8> [#uses=1]
+	%tmp213.us = or i8 %tmp211, %tmp210.us		; <i8> [#uses=1]
+	%tmp215.us = load i8* %dest.1.0.us		; <i8> [#uses=1]
+	%tmp216.us = and i8 %tmp213.us, %tmp215.us		; <i8> [#uses=1]
+	%tmp221.us = and i32 %tmp219, %tmp208.us		; <i32> [#uses=1]
+	%tmp221.us.upgrd.20 = trunc i32 %tmp221.us to i8		; <i8> [#uses=1]
+	%tmp222.us = or i8 %tmp216.us, %tmp221.us.upgrd.20		; <i8> [#uses=1]
+	store i8 %tmp222.us, i8* %dest.1.0.us
+	br i1 true, label %bb252.us, label %cond_true249.preheader.us
 
 cond_next280.us:		; preds = %bb252.us, %cond_true255.us
-	%tmp281.us = cast ubyte** %dest_line.1.0.us to uint		; <uint> [#uses=1]
-	%tmp282.us = add uint %tmp281.us, 4		; <uint> [#uses=1]
-	%tmp282.us = cast uint %tmp282.us to ubyte**		; <ubyte**> [#uses=2]
-	%tmp284.us = load ubyte** %tmp282.us		; <ubyte*> [#uses=1]
-	%tmp286.us = getelementptr ubyte* %tmp284.us, int %tmp93		; <ubyte*> [#uses=1]
-	%tmp292.us = add int %tmp292.0.us, -1		; <int> [#uses=1]
-	%tmp294.us = setlt int %tmp292.us, 0		; <bool> [#uses=1]
-	%indvar.next87 = add uint %indvar86, 1		; <uint> [#uses=1]
-	br bool %tmp294.us, label %return.loopexit.us, label %cond_true295.us
+	%tmp281.us = ptrtoint i8** %dest_line.1.0.us to i32		; <i32> [#uses=1]
+	%tmp282.us = add i32 %tmp281.us, 4		; <i32> [#uses=1]
+	%tmp282.us.upgrd.21 = inttoptr i32 %tmp282.us to i8**		; <i8**> [#uses=2]
+	%tmp284.us = load i8** %tmp282.us.upgrd.21		; <i8*> [#uses=1]
+	%tmp286.us = getelementptr i8* %tmp284.us, i32 %tmp93		; <i8*> [#uses=1]
+	%tmp292.us = add i32 %tmp292.0.us, -1		; <i32> [#uses=1]
+	%tmp294.us = icmp slt i32 %tmp292.us, 0		; <i1> [#uses=1]
+	%indvar.next87 = add i32 %indvar86, 1		; <i32> [#uses=1]
+	br i1 %tmp294.us, label %return.loopexit.us, label %cond_true295.us
 
 cond_true255.us:		; preds = %bb252.us
-	%tmp256.us = cast ubyte* %bptr.3.3.us to uint		; <uint> [#uses=1]
-	%tmp257.us = add uint %tmp256.us, 1		; <uint> [#uses=1]
-	%tmp257.us = cast uint %tmp257.us to ubyte*		; <ubyte*> [#uses=1]
-	%tmp259.us = load ubyte* %tmp257.us		; <ubyte> [#uses=1]
-	%tmp259.us = cast ubyte %tmp259.us to uint		; <uint> [#uses=1]
-	%tmp261.us = xor uint %tmp259.us, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp262.us = cast ubyte* %optr.3.3.us to uint		; <uint> [#uses=1]
-	%tmp263.us = add uint %tmp262.us, 1		; <uint> [#uses=1]
-	%tmp263.us = cast uint %tmp263.us to ubyte*		; <ubyte*> [#uses=2]
-	%tmp265.us = cast uint %tmp261.us to ubyte		; <ubyte> [#uses=1]
-	%tmp268.us = or ubyte %tmp266, %tmp265.us		; <ubyte> [#uses=1]
-	%tmp270.us = load ubyte* %tmp263.us		; <ubyte> [#uses=1]
-	%tmp271.us = and ubyte %tmp268.us, %tmp270.us		; <ubyte> [#uses=1]
-	%tmp276.us = and uint %tmp274, %tmp261.us		; <uint> [#uses=1]
-	%tmp276.us = cast uint %tmp276.us to ubyte		; <ubyte> [#uses=1]
-	%tmp277.us = or ubyte %tmp271.us, %tmp276.us		; <ubyte> [#uses=1]
-	store ubyte %tmp277.us, ubyte* %tmp263.us
+	%tmp256.us = ptrtoint i8* %bptr.3.3.us to i32		; <i32> [#uses=1]
+	%tmp257.us = add i32 %tmp256.us, 1		; <i32> [#uses=1]
+	%tmp257.us.upgrd.22 = inttoptr i32 %tmp257.us to i8*		; <i8*> [#uses=1]
+	%tmp259.us = load i8* %tmp257.us.upgrd.22		; <i8> [#uses=1]
+	%tmp259.us.upgrd.23 = zext i8 %tmp259.us to i32		; <i32> [#uses=1]
+	%tmp261.us = xor i32 %tmp259.us.upgrd.23, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp262.us = ptrtoint i8* %optr.3.3.us to i32		; <i32> [#uses=1]
+	%tmp263.us = add i32 %tmp262.us, 1		; <i32> [#uses=1]
+	%tmp263.us.upgrd.24 = inttoptr i32 %tmp263.us to i8*		; <i8*> [#uses=2]
+	%tmp265.us = trunc i32 %tmp261.us to i8		; <i8> [#uses=1]
+	%tmp268.us = or i8 %tmp266, %tmp265.us		; <i8> [#uses=1]
+	%tmp270.us = load i8* %tmp263.us.upgrd.24		; <i8> [#uses=1]
+	%tmp271.us = and i8 %tmp268.us, %tmp270.us		; <i8> [#uses=1]
+	%tmp276.us = and i32 %tmp274, %tmp261.us		; <i32> [#uses=1]
+	%tmp276.us.upgrd.25 = trunc i32 %tmp276.us to i8		; <i8> [#uses=1]
+	%tmp277.us = or i8 %tmp271.us, %tmp276.us.upgrd.25		; <i8> [#uses=1]
+	store i8 %tmp277.us, i8* %tmp263.us.upgrd.24
 	br label %cond_next280.us
 
 bb252.us:		; preds = %bb252.loopexit.us, %cond_true295.us
-	%optr.3.3.us = phi ubyte* [ %dest.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <ubyte*> [#uses=1]
-	%bptr.3.3.us = phi ubyte* [ %line.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <ubyte*> [#uses=1]
-	%tmp246.3.us = phi int [ %tmp246, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <int> [#uses=1]
-	%tmp254.us = setgt int %tmp246.3.us, -8		; <bool> [#uses=1]
-	br bool %tmp254.us, label %cond_true255.us, label %cond_next280.us
+	%optr.3.3.us = phi i8* [ %dest.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <i8*> [#uses=1]
+	%bptr.3.3.us = phi i8* [ %line.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <i8*> [#uses=1]
+	%tmp246.3.us = phi i32 [ %tmp246, %cond_true295.us ], [ undef, %bb252.loopexit.us ]		; <i32> [#uses=1]
+	%tmp254.us = icmp sgt i32 %tmp246.3.us, -8		; <i1> [#uses=1]
+	br i1 %tmp254.us, label %cond_true255.us, label %cond_next280.us
 
 cond_true249.us:		; preds = %cond_true249.preheader.us, %cond_true249.us
-	br bool undef, label %bb252.loopexit.us, label %cond_true249.us
+	br i1 undef, label %bb252.loopexit.us, label %cond_true249.us
 
 cond_true249.preheader.us:		; preds = %cond_true295.us
 	br label %cond_true249.us
@@ -310,197 +305,197 @@ cond_true295.preheader.split:		; preds = %cond_true295.preheader
 	br label %cond_true295
 
 cond_true295:		; preds = %cond_true295.preheader.split, %cond_next280
-	%indvar60 = phi uint [ 0, %cond_true295.preheader.split ], [ %indvar.next61, %cond_next280 ]		; <uint> [#uses=3]
-	%dest.1.0 = phi ubyte* [ %tmp286, %cond_next280 ], [ %tmp100, %cond_true295.preheader.split ]		; <ubyte*> [#uses=4]
-	%dest_line.1.0 = phi ubyte** [ %tmp282, %cond_next280 ], [ %tmp96, %cond_true295.preheader.split ]		; <ubyte**> [#uses=1]
-	%tmp.63 = sub uint 0, %indvar60		; <uint> [#uses=1]
-	%tmp.63 = cast uint %tmp.63 to int		; <int> [#uses=1]
-	%tmp292.0 = add int %tmp.63, %tmp29222		; <int> [#uses=1]
-	%tmp.65 = mul uint %indvar60, %raster		; <uint> [#uses=1]
-	%tmp.65 = cast uint %tmp.65 to int		; <int> [#uses=1]
-	%tmp104.sum97 = add int %tmp102, %tmp.65		; <int> [#uses=1]
-	%line.1.0 = getelementptr ubyte* %base, int %tmp104.sum97		; <ubyte*> [#uses=3]
-	%tmp = load ubyte* %line.1.0		; <ubyte> [#uses=1]
-	%tmp206 = cast ubyte %tmp to uint		; <uint> [#uses=1]
-	%tmp208 = xor uint %tmp206, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp210 = cast uint %tmp208 to ubyte		; <ubyte> [#uses=1]
-	%tmp213 = or ubyte %tmp211, %tmp210		; <ubyte> [#uses=1]
-	%tmp215 = load ubyte* %dest.1.0		; <ubyte> [#uses=1]
-	%tmp216 = and ubyte %tmp213, %tmp215		; <ubyte> [#uses=1]
-	%tmp221 = and uint %tmp219, %tmp208		; <uint> [#uses=1]
-	%tmp221 = cast uint %tmp221 to ubyte		; <ubyte> [#uses=1]
-	%tmp222 = or ubyte %tmp216, %tmp221		; <ubyte> [#uses=1]
-	store ubyte %tmp222, ubyte* %dest.1.0
-	br bool false, label %bb252, label %cond_true249.preheader
+	%indvar60 = phi i32 [ 0, %cond_true295.preheader.split ], [ %indvar.next61, %cond_next280 ]		; <i32> [#uses=3]
+	%dest.1.0 = phi i8* [ %tmp286, %cond_next280 ], [ %tmp100, %cond_true295.preheader.split ]		; <i8*> [#uses=4]
+	%dest_line.1.0 = phi i8** [ %tmp282.upgrd.19, %cond_next280 ], [ %tmp96, %cond_true295.preheader.split ]		; <i8**> [#uses=1]
+	%tmp.63 = sub i32 0, %indvar60		; <i32> [#uses=2]
+	%tmp292.0 = add i32 %tmp.63, %tmp29222		; <i32> [#uses=1]
+	%tmp.65 = mul i32 %indvar60, %raster		; <i32> [#uses=2]
+	%tmp104.sum97 = add i32 %tmp102, %tmp.65		; <i32> [#uses=1]
+	%line.1.0 = getelementptr i8* %base, i32 %tmp104.sum97		; <i8*> [#uses=3]
+	%tmp.upgrd.26 = load i8* %line.1.0		; <i8> [#uses=1]
+	%tmp206 = zext i8 %tmp.upgrd.26 to i32		; <i32> [#uses=1]
+	%tmp208 = xor i32 %tmp206, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp210 = trunc i32 %tmp208 to i8		; <i8> [#uses=1]
+	%tmp213 = or i8 %tmp211, %tmp210		; <i8> [#uses=1]
+	%tmp215 = load i8* %dest.1.0		; <i8> [#uses=1]
+	%tmp216 = and i8 %tmp213, %tmp215		; <i8> [#uses=1]
+	%tmp221 = and i32 %tmp219, %tmp208		; <i32> [#uses=1]
+	%tmp221.upgrd.27 = trunc i32 %tmp221 to i8		; <i8> [#uses=1]
+	%tmp222 = or i8 %tmp216, %tmp221.upgrd.27		; <i8> [#uses=1]
+	store i8 %tmp222, i8* %dest.1.0
+	br i1 false, label %bb252, label %cond_true249.preheader
 
 cond_false299:		; preds = %cond_next151
-	%tmp302 = sub int %tmp107, %tmp110		; <int> [#uses=1]
-	%tmp303 = and int %tmp302, 7		; <int> [#uses=3]
-	%tmp305 = sub int 8, %tmp303		; <int> [#uses=1]
-	%tmp45438 = add int %h, -1		; <int> [#uses=2]
-	%tmp45640 = setlt int %tmp45438, 0		; <bool> [#uses=1]
-	br bool %tmp45640, label %return, label %cond_true457.preheader
+	%tmp302 = sub i32 %tmp107, %tmp110		; <i32> [#uses=1]
+	%tmp303 = and i32 %tmp302, 7		; <i32> [#uses=3]
+	%tmp305 = sub i32 8, %tmp303		; <i32> [#uses=1]
+	%tmp45438 = add i32 %h, -1		; <i32> [#uses=2]
+	%tmp45640 = icmp slt i32 %tmp45438, 0		; <i1> [#uses=1]
+	br i1 %tmp45640, label %return, label %cond_true457.preheader
 
 cond_true316:		; preds = %cond_true457
-	%tmp318 = cast ubyte %tmp318 to uint		; <uint> [#uses=1]
-	%tmp320 = shr uint %tmp318, ubyte %tmp319		; <uint> [#uses=1]
+	%tmp318 = zext i8 %tmp318.upgrd.48 to i32		; <i32> [#uses=1]
+	%shift.upgrd.28 = zext i8 %tmp319 to i32		; <i32> [#uses=1]
+	%tmp320 = lshr i32 %tmp318, %shift.upgrd.28		; <i32> [#uses=1]
 	br label %cond_next340
 
 cond_false321:		; preds = %cond_true457
-	%tmp3188 = cast ubyte %tmp318 to uint		; <uint> [#uses=1]
-	%tmp325 = shl uint %tmp3188, ubyte %tmp324		; <uint> [#uses=2]
-	%tmp326 = cast ubyte* %line.3.0 to uint		; <uint> [#uses=1]
-	%tmp327 = add uint %tmp326, 1		; <uint> [#uses=1]
-	%tmp327 = cast uint %tmp327 to ubyte*		; <ubyte*> [#uses=3]
-	br bool %tmp330, label %cond_true331, label %cond_next340
+	%tmp3188 = zext i8 %tmp318.upgrd.48 to i32		; <i32> [#uses=1]
+	%shift.upgrd.29 = zext i8 %tmp324 to i32		; <i32> [#uses=1]
+	%tmp325 = shl i32 %tmp3188, %shift.upgrd.29		; <i32> [#uses=2]
+	%tmp326 = ptrtoint i8* %line.3.0 to i32		; <i32> [#uses=1]
+	%tmp327 = add i32 %tmp326, 1		; <i32> [#uses=1]
+	%tmp327.upgrd.30 = inttoptr i32 %tmp327 to i8*		; <i8*> [#uses=3]
+	br i1 %tmp330, label %cond_true331, label %cond_next340
 
 cond_true331:		; preds = %cond_false321
-	%tmp333 = load ubyte* %tmp327		; <ubyte> [#uses=1]
-	%tmp333 = cast ubyte %tmp333 to uint		; <uint> [#uses=1]
-	%tmp335 = shr uint %tmp333, ubyte %tmp319		; <uint> [#uses=1]
-	%tmp337 = add uint %tmp335, %tmp325		; <uint> [#uses=1]
+	%tmp333 = load i8* %tmp327.upgrd.30		; <i8> [#uses=1]
+	%tmp333.upgrd.31 = zext i8 %tmp333 to i32		; <i32> [#uses=1]
+	%shift.upgrd.32 = zext i8 %tmp319 to i32		; <i32> [#uses=1]
+	%tmp335 = lshr i32 %tmp333.upgrd.31, %shift.upgrd.32		; <i32> [#uses=1]
+	%tmp337 = add i32 %tmp335, %tmp325		; <i32> [#uses=1]
 	br label %cond_next340
 
 cond_next340:		; preds = %cond_true331, %cond_false321, %cond_true316
-	%bits.0 = phi uint [ %tmp320, %cond_true316 ], [ %tmp337, %cond_true331 ], [ %tmp325, %cond_false321 ]		; <uint> [#uses=1]
-	%bptr307.3 = phi ubyte* [ %line.3.0, %cond_true316 ], [ %tmp327, %cond_true331 ], [ %tmp327, %cond_false321 ]		; <ubyte*> [#uses=2]
-	%tmp343 = xor uint %bits.0, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp345 = cast uint %tmp343 to ubyte		; <ubyte> [#uses=1]
-	%tmp348 = or ubyte %tmp346, %tmp345		; <ubyte> [#uses=1]
-	%tmp350 = load ubyte* %dest.3.0		; <ubyte> [#uses=1]
-	%tmp351 = and ubyte %tmp348, %tmp350		; <ubyte> [#uses=1]
-	%tmp356 = and uint %tmp354, %tmp343		; <uint> [#uses=1]
-	%tmp356 = cast uint %tmp356 to ubyte		; <ubyte> [#uses=1]
-	%tmp357 = or ubyte %tmp351, %tmp356		; <ubyte> [#uses=1]
-	store ubyte %tmp357, ubyte* %dest.3.0
-	%tmp362 = cast ubyte* %dest.3.0 to uint		; <uint> [#uses=1]
-	%optr309.3.in51 = add uint %tmp362, 1		; <uint> [#uses=2]
-	%optr309.353 = cast uint %optr309.3.in51 to ubyte*		; <ubyte*> [#uses=2]
-	br bool %tmp39755, label %cond_true398.preheader, label %bb401
+	%bits.0 = phi i32 [ %tmp320, %cond_true316 ], [ %tmp337, %cond_true331 ], [ %tmp325, %cond_false321 ]		; <i32> [#uses=1]
+	%bptr307.3 = phi i8* [ %line.3.0, %cond_true316 ], [ %tmp327.upgrd.30, %cond_true331 ], [ %tmp327.upgrd.30, %cond_false321 ]		; <i8*> [#uses=2]
+	%tmp343 = xor i32 %bits.0, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp345 = trunc i32 %tmp343 to i8		; <i8> [#uses=1]
+	%tmp348 = or i8 %tmp346, %tmp345		; <i8> [#uses=1]
+	%tmp350 = load i8* %dest.3.0		; <i8> [#uses=1]
+	%tmp351 = and i8 %tmp348, %tmp350		; <i8> [#uses=1]
+	%tmp356 = and i32 %tmp354, %tmp343		; <i32> [#uses=1]
+	%tmp356.upgrd.33 = trunc i32 %tmp356 to i8		; <i8> [#uses=1]
+	%tmp357 = or i8 %tmp351, %tmp356.upgrd.33		; <i8> [#uses=1]
+	store i8 %tmp357, i8* %dest.3.0
+	%tmp362 = ptrtoint i8* %dest.3.0 to i32		; <i32> [#uses=1]
+	%optr309.3.in51 = add i32 %tmp362, 1		; <i32> [#uses=2]
+	%optr309.353 = inttoptr i32 %optr309.3.in51 to i8*		; <i8*> [#uses=2]
+	br i1 %tmp39755, label %cond_true398.preheader, label %bb401
 
 cond_true398.preheader:		; preds = %cond_next340
 	br label %cond_true398
 
 cond_true398:		; preds = %cond_true398, %cond_true398.preheader
-	%indvar66 = phi uint [ 0, %cond_true398.preheader ], [ %indvar.next67, %cond_true398 ]		; <uint> [#uses=3]
-	%bptr307.4.0 = phi ubyte* [ %tmp370, %cond_true398 ], [ %bptr307.3, %cond_true398.preheader ]		; <ubyte*> [#uses=2]
-	%optr309.3.0 = phi ubyte* [ %optr309.3, %cond_true398 ], [ %optr309.353, %cond_true398.preheader ]		; <ubyte*> [#uses=2]
-	%optr309.3.in.0 = add uint %indvar66, %optr309.3.in51		; <uint> [#uses=1]
-	%tmp.70 = add int %tmp109, %w		; <int> [#uses=1]
-	%indvar66 = cast uint %indvar66 to int		; <int> [#uses=1]
-	%tmp.72 = mul int %indvar66, -8		; <int> [#uses=1]
-	%tmp.71 = add int %tmp.70, -8		; <int> [#uses=1]
-	%count308.3.0 = add int %tmp.72, %tmp.71		; <int> [#uses=1]
-	%tmp366 = load ubyte* %bptr307.4.0		; <ubyte> [#uses=1]
-	%tmp366 = cast ubyte %tmp366 to uint		; <uint> [#uses=1]
-	%tmp369 = cast ubyte* %bptr307.4.0 to uint		; <uint> [#uses=1]
-	%tmp370 = add uint %tmp369, 1		; <uint> [#uses=1]
-	%tmp370 = cast uint %tmp370 to ubyte*		; <ubyte*> [#uses=3]
-	%tmp372 = load ubyte* %tmp370		; <ubyte> [#uses=1]
-	%tmp372 = cast ubyte %tmp372 to uint		; <uint> [#uses=1]
-	%tmp374463 = shr uint %tmp372, ubyte %tmp319		; <uint> [#uses=1]
-	%tmp368 = shl uint %tmp366, ubyte %tmp324		; <uint> [#uses=1]
-	%tmp377 = add uint %tmp374463, %tmp368		; <uint> [#uses=1]
-	%tmp379 = xor uint %tmp377, %iftmp.35.0		; <uint> [#uses=2]
-	%tmp382 = or uint %tmp379, %iftmp.36.0		; <uint> [#uses=1]
-	%tmp382 = cast uint %tmp382 to ubyte		; <ubyte> [#uses=1]
-	%tmp384 = load ubyte* %optr309.3.0		; <ubyte> [#uses=1]
-	%tmp385 = and ubyte %tmp382, %tmp384		; <ubyte> [#uses=1]
-	%tmp388 = and uint %tmp379, %iftmp.37.0		; <uint> [#uses=1]
-	%tmp388 = cast uint %tmp388 to ubyte		; <ubyte> [#uses=1]
-	%tmp389 = or ubyte %tmp385, %tmp388		; <ubyte> [#uses=1]
-	store ubyte %tmp389, ubyte* %optr309.3.0
-	%tmp392 = add int %count308.3.0, -8		; <int> [#uses=2]
-	%optr309.3.in = add uint %optr309.3.in.0, 1		; <uint> [#uses=1]
-	%optr309.3 = cast uint %optr309.3.in to ubyte*		; <ubyte*> [#uses=2]
-	%tmp397 = setgt int %tmp392, 7		; <bool> [#uses=1]
-	%indvar.next67 = add uint %indvar66, 1		; <uint> [#uses=1]
-	br bool %tmp397, label %cond_true398, label %bb401.loopexit
+	%indvar66 = phi i32 [ 0, %cond_true398.preheader ], [ %indvar.next67, %cond_true398 ]		; <i32> [#uses=4]
+	%bptr307.4.0 = phi i8* [ %tmp370.upgrd.35, %cond_true398 ], [ %bptr307.3, %cond_true398.preheader ]		; <i8*> [#uses=2]
+	%optr309.3.0 = phi i8* [ %optr309.3, %cond_true398 ], [ %optr309.353, %cond_true398.preheader ]		; <i8*> [#uses=2]
+	%optr309.3.in.0 = add i32 %indvar66, %optr309.3.in51		; <i32> [#uses=1]
+	%tmp.70 = add i32 %tmp109, %w		; <i32> [#uses=1]
+	%tmp.72 = mul i32 %indvar66, -8		; <i32> [#uses=1]
+	%tmp.71 = add i32 %tmp.70, -8		; <i32> [#uses=1]
+	%count308.3.0 = add i32 %tmp.72, %tmp.71		; <i32> [#uses=1]
+	%tmp366 = load i8* %bptr307.4.0		; <i8> [#uses=1]
+	%tmp366.upgrd.34 = zext i8 %tmp366 to i32		; <i32> [#uses=1]
+	%tmp369 = ptrtoint i8* %bptr307.4.0 to i32		; <i32> [#uses=1]
+	%tmp370 = add i32 %tmp369, 1		; <i32> [#uses=1]
+	%tmp370.upgrd.35 = inttoptr i32 %tmp370 to i8*		; <i8*> [#uses=3]
+	%tmp372 = load i8* %tmp370.upgrd.35		; <i8> [#uses=1]
+	%tmp372.upgrd.36 = zext i8 %tmp372 to i32		; <i32> [#uses=1]
+	%shift.upgrd.37 = zext i8 %tmp319 to i32		; <i32> [#uses=1]
+	%tmp374463 = lshr i32 %tmp372.upgrd.36, %shift.upgrd.37		; <i32> [#uses=1]
+	%shift.upgrd.38 = zext i8 %tmp324 to i32		; <i32> [#uses=1]
+	%tmp368 = shl i32 %tmp366.upgrd.34, %shift.upgrd.38		; <i32> [#uses=1]
+	%tmp377 = add i32 %tmp374463, %tmp368		; <i32> [#uses=1]
+	%tmp379 = xor i32 %tmp377, %iftmp.35.0		; <i32> [#uses=2]
+	%tmp382 = or i32 %tmp379, %iftmp.36.0		; <i32> [#uses=1]
+	%tmp382.upgrd.39 = trunc i32 %tmp382 to i8		; <i8> [#uses=1]
+	%tmp384 = load i8* %optr309.3.0		; <i8> [#uses=1]
+	%tmp385 = and i8 %tmp382.upgrd.39, %tmp384		; <i8> [#uses=1]
+	%tmp388 = and i32 %tmp379, %iftmp.37.0		; <i32> [#uses=1]
+	%tmp388.upgrd.40 = trunc i32 %tmp388 to i8		; <i8> [#uses=1]
+	%tmp389 = or i8 %tmp385, %tmp388.upgrd.40		; <i8> [#uses=1]
+	store i8 %tmp389, i8* %optr309.3.0
+	%tmp392 = add i32 %count308.3.0, -8		; <i32> [#uses=2]
+	%optr309.3.in = add i32 %optr309.3.in.0, 1		; <i32> [#uses=1]
+	%optr309.3 = inttoptr i32 %optr309.3.in to i8*		; <i8*> [#uses=2]
+	%tmp397 = icmp sgt i32 %tmp392, 7		; <i1> [#uses=1]
+	%indvar.next67 = add i32 %indvar66, 1		; <i32> [#uses=1]
+	br i1 %tmp397, label %cond_true398, label %bb401.loopexit
 
 bb401.loopexit:		; preds = %cond_true398
 	br label %bb401
 
 bb401:		; preds = %bb401.loopexit, %cond_next340
-	%count308.3.1 = phi int [ %tmp361, %cond_next340 ], [ %tmp392, %bb401.loopexit ]		; <int> [#uses=2]
-	%bptr307.4.1 = phi ubyte* [ %bptr307.3, %cond_next340 ], [ %tmp370, %bb401.loopexit ]		; <ubyte*> [#uses=2]
-	%optr309.3.1 = phi ubyte* [ %optr309.353, %cond_next340 ], [ %optr309.3, %bb401.loopexit ]		; <ubyte*> [#uses=2]
-	%tmp403 = setgt int %count308.3.1, 0		; <bool> [#uses=1]
-	br bool %tmp403, label %cond_true404, label %cond_next442
+	%count308.3.1 = phi i32 [ %tmp361, %cond_next340 ], [ %tmp392, %bb401.loopexit ]		; <i32> [#uses=2]
+	%bptr307.4.1 = phi i8* [ %bptr307.3, %cond_next340 ], [ %tmp370.upgrd.35, %bb401.loopexit ]		; <i8*> [#uses=2]
+	%optr309.3.1 = phi i8* [ %optr309.353, %cond_next340 ], [ %optr309.3, %bb401.loopexit ]		; <i8*> [#uses=2]
+	%tmp403 = icmp sgt i32 %count308.3.1, 0		; <i1> [#uses=1]
+	br i1 %tmp403, label %cond_true404, label %cond_next442
 
 cond_true404:		; preds = %bb401
-	%tmp406 = load ubyte* %bptr307.4.1		; <ubyte> [#uses=1]
-	%tmp406 = cast ubyte %tmp406 to int		; <int> [#uses=1]
-	%tmp408 = shl int %tmp406, ubyte %tmp324		; <int> [#uses=2]
-	%tmp413 = setgt int %count308.3.1, %tmp303		; <bool> [#uses=1]
-	br bool %tmp413, label %cond_true414, label %cond_next422
+	%tmp406 = load i8* %bptr307.4.1		; <i8> [#uses=1]
+	%tmp406.upgrd.41 = zext i8 %tmp406 to i32		; <i32> [#uses=1]
+	%shift.upgrd.42 = zext i8 %tmp324 to i32		; <i32> [#uses=1]
+	%tmp408 = shl i32 %tmp406.upgrd.41, %shift.upgrd.42		; <i32> [#uses=2]
+	%tmp413 = icmp sgt i32 %count308.3.1, %tmp303		; <i1> [#uses=1]
+	br i1 %tmp413, label %cond_true414, label %cond_next422
 
 cond_true414:		; preds = %cond_true404
-	%tmp409 = cast ubyte* %bptr307.4.1 to uint		; <uint> [#uses=1]
-	%tmp410 = add uint %tmp409, 1		; <uint> [#uses=1]
-	%tmp410 = cast uint %tmp410 to ubyte*		; <ubyte*> [#uses=1]
-	%tmp416 = load ubyte* %tmp410		; <ubyte> [#uses=1]
-	%tmp416 = cast ubyte %tmp416 to uint		; <uint> [#uses=1]
-	%tmp418 = shr uint %tmp416, ubyte %tmp319		; <uint> [#uses=1]
-	%tmp418 = cast uint %tmp418 to int		; <int> [#uses=1]
-	%tmp420 = add int %tmp418, %tmp408		; <int> [#uses=1]
+	%tmp409 = ptrtoint i8* %bptr307.4.1 to i32		; <i32> [#uses=1]
+	%tmp410 = add i32 %tmp409, 1		; <i32> [#uses=1]
+	%tmp410.upgrd.43 = inttoptr i32 %tmp410 to i8*		; <i8*> [#uses=1]
+	%tmp416 = load i8* %tmp410.upgrd.43		; <i8> [#uses=1]
+	%tmp416.upgrd.44 = zext i8 %tmp416 to i32		; <i32> [#uses=1]
+	%shift.upgrd.45 = zext i8 %tmp319 to i32		; <i32> [#uses=1]
+	%tmp418 = lshr i32 %tmp416.upgrd.44, %shift.upgrd.45		; <i32> [#uses=2]
+	%tmp420 = add i32 %tmp418, %tmp408		; <i32> [#uses=1]
 	br label %cond_next422
 
 cond_next422:		; preds = %cond_true414, %cond_true404
-	%bits.6 = phi int [ %tmp420, %cond_true414 ], [ %tmp408, %cond_true404 ]		; <int> [#uses=1]
-	%tmp425 = xor int %bits.6, %iftmp.35.0		; <int> [#uses=1]
-	%tmp427 = cast int %tmp425 to ubyte		; <ubyte> [#uses=2]
-	%tmp430 = or ubyte %tmp428, %tmp427		; <ubyte> [#uses=1]
-	%tmp432 = load ubyte* %optr309.3.1		; <ubyte> [#uses=1]
-	%tmp433 = and ubyte %tmp430, %tmp432		; <ubyte> [#uses=1]
-	%tmp438 = and ubyte %tmp436, %tmp427		; <ubyte> [#uses=1]
-	%tmp439 = or ubyte %tmp433, %tmp438		; <ubyte> [#uses=1]
-	store ubyte %tmp439, ubyte* %optr309.3.1
+	%bits.6 = phi i32 [ %tmp420, %cond_true414 ], [ %tmp408, %cond_true404 ]		; <i32> [#uses=1]
+	%tmp425 = xor i32 %bits.6, %iftmp.35.0		; <i32> [#uses=1]
+	%tmp427 = trunc i32 %tmp425 to i8		; <i8> [#uses=2]
+	%tmp430 = or i8 %tmp428, %tmp427		; <i8> [#uses=1]
+	%tmp432 = load i8* %optr309.3.1		; <i8> [#uses=1]
+	%tmp433 = and i8 %tmp430, %tmp432		; <i8> [#uses=1]
+	%tmp438 = and i8 %tmp436.upgrd.47, %tmp427		; <i8> [#uses=1]
+	%tmp439 = or i8 %tmp433, %tmp438		; <i8> [#uses=1]
+	store i8 %tmp439, i8* %optr309.3.1
 	br label %cond_next442
 
 cond_next442:		; preds = %cond_next422, %bb401
-	%tmp443 = cast ubyte** %dest_line.3.0 to uint		; <uint> [#uses=1]
-	%tmp444 = add uint %tmp443, 4		; <uint> [#uses=1]
-	%tmp444 = cast uint %tmp444 to ubyte**		; <ubyte**> [#uses=2]
-	%tmp446 = load ubyte** %tmp444		; <ubyte*> [#uses=1]
-	%tmp448 = getelementptr ubyte* %tmp446, int %tmp93		; <ubyte*> [#uses=1]
-	%tmp454 = add int %tmp454.0, -1		; <int> [#uses=1]
-	%tmp456 = setlt int %tmp454, 0		; <bool> [#uses=1]
-	%indvar.next75 = add uint %indvar74, 1		; <uint> [#uses=1]
-	br bool %tmp456, label %return.loopexit56, label %cond_true457
+	%tmp443 = ptrtoint i8** %dest_line.3.0 to i32		; <i32> [#uses=1]
+	%tmp444 = add i32 %tmp443, 4		; <i32> [#uses=1]
+	%tmp444.upgrd.46 = inttoptr i32 %tmp444 to i8**		; <i8**> [#uses=2]
+	%tmp446 = load i8** %tmp444.upgrd.46		; <i8*> [#uses=1]
+	%tmp448 = getelementptr i8* %tmp446, i32 %tmp93		; <i8*> [#uses=1]
+	%tmp454 = add i32 %tmp454.0, -1		; <i32> [#uses=1]
+	%tmp456 = icmp slt i32 %tmp454, 0		; <i1> [#uses=1]
+	%indvar.next75 = add i32 %indvar74, 1		; <i32> [#uses=1]
+	br i1 %tmp456, label %return.loopexit56, label %cond_true457
 
 cond_true457.preheader:		; preds = %cond_false299
-	%tmp315 = setlt int %tmp107, %tmp110		; <bool> [#uses=1]
-	%tmp319 = cast int %tmp303 to ubyte		; <ubyte> [#uses=4]
-	%tmp324 = cast int %tmp305 to ubyte		; <ubyte> [#uses=3]
-	%tmp330 = setlt int %tmp107, %w		; <bool> [#uses=1]
-	%tmp344 = cast uint %mask.1.1 to ubyte		; <ubyte> [#uses=1]
-	%tmp344not = xor ubyte %tmp344, 255		; <ubyte> [#uses=1]
-	%tmp347 = cast uint %iftmp.36.0 to ubyte		; <ubyte> [#uses=2]
-	%tmp346 = or ubyte %tmp347, %tmp344not		; <ubyte> [#uses=1]
-	%tmp354 = and uint %iftmp.37.0, %mask.1.1		; <uint> [#uses=1]
-	%tmp361 = sub int %w, %tmp110		; <int> [#uses=2]
-	%tmp39755 = setgt int %tmp361, 7		; <bool> [#uses=1]
-	%iftmp.35.0 = cast uint %iftmp.35.0 to int		; <int> [#uses=1]
-	%tmp426 = cast uint %rmask.0.1 to ubyte		; <ubyte> [#uses=1]
-	%tmp426not = xor ubyte %tmp426, 255		; <ubyte> [#uses=1]
-	%tmp428 = or ubyte %tmp347, %tmp426not		; <ubyte> [#uses=1]
-	%tmp436 = and uint %iftmp.37.0, %rmask.0.1		; <uint> [#uses=1]
-	%tmp436 = cast uint %tmp436 to ubyte		; <ubyte> [#uses=1]
+	%tmp315 = icmp slt i32 %tmp107, %tmp110		; <i1> [#uses=1]
+	%tmp319 = trunc i32 %tmp303 to i8		; <i8> [#uses=4]
+	%tmp324 = trunc i32 %tmp305 to i8		; <i8> [#uses=3]
+	%tmp330 = icmp slt i32 %tmp107, %w		; <i1> [#uses=1]
+	%tmp344 = trunc i32 %mask.1.1 to i8		; <i8> [#uses=1]
+	%tmp344not = xor i8 %tmp344, -1		; <i8> [#uses=1]
+	%tmp347 = trunc i32 %iftmp.36.0 to i8		; <i8> [#uses=2]
+	%tmp346 = or i8 %tmp347, %tmp344not		; <i8> [#uses=1]
+	%tmp354 = and i32 %iftmp.37.0, %mask.1.1		; <i32> [#uses=1]
+	%tmp361 = sub i32 %w, %tmp110		; <i32> [#uses=2]
+	%tmp39755 = icmp sgt i32 %tmp361, 7		; <i1> [#uses=1]
+	%tmp426 = trunc i32 %rmask.0.1 to i8		; <i8> [#uses=1]
+	%tmp426not = xor i8 %tmp426, -1		; <i8> [#uses=1]
+	%tmp428 = or i8 %tmp347, %tmp426not		; <i8> [#uses=1]
+	%tmp436 = and i32 %iftmp.37.0, %rmask.0.1		; <i32> [#uses=1]
+	%tmp436.upgrd.47 = trunc i32 %tmp436 to i8		; <i8> [#uses=1]
 	br label %cond_true457
 
 cond_true457:		; preds = %cond_true457.preheader, %cond_next442
-	%indvar74 = phi uint [ 0, %cond_true457.preheader ], [ %indvar.next75, %cond_next442 ]		; <uint> [#uses=3]
-	%dest.3.0 = phi ubyte* [ %tmp448, %cond_next442 ], [ %tmp100, %cond_true457.preheader ]		; <ubyte*> [#uses=3]
-	%dest_line.3.0 = phi ubyte** [ %tmp444, %cond_next442 ], [ %tmp96, %cond_true457.preheader ]		; <ubyte**> [#uses=1]
-	%tmp.77 = sub uint 0, %indvar74		; <uint> [#uses=1]
-	%tmp.77 = cast uint %tmp.77 to int		; <int> [#uses=1]
-	%tmp454.0 = add int %tmp.77, %tmp45438		; <int> [#uses=1]
-	%tmp.79 = mul uint %indvar74, %raster		; <uint> [#uses=1]
-	%tmp.79 = cast uint %tmp.79 to int		; <int> [#uses=1]
-	%tmp104.sum = add int %tmp102, %tmp.79		; <int> [#uses=1]
-	%line.3.0 = getelementptr ubyte* %base, int %tmp104.sum		; <ubyte*> [#uses=3]
-	%tmp318 = load ubyte* %line.3.0		; <ubyte> [#uses=2]
-	br bool %tmp315, label %cond_false321, label %cond_true316
+	%indvar74 = phi i32 [ 0, %cond_true457.preheader ], [ %indvar.next75, %cond_next442 ]		; <i32> [#uses=3]
+	%dest.3.0 = phi i8* [ %tmp448, %cond_next442 ], [ %tmp100, %cond_true457.preheader ]		; <i8*> [#uses=3]
+	%dest_line.3.0 = phi i8** [ %tmp444.upgrd.46, %cond_next442 ], [ %tmp96, %cond_true457.preheader ]		; <i8**> [#uses=1]
+	%tmp.77 = sub i32 0, %indvar74		; <i32> [#uses=2]
+	%tmp454.0 = add i32 %tmp.77, %tmp45438		; <i32> [#uses=1]
+	%tmp.79 = mul i32 %indvar74, %raster		; <i32> [#uses=2]
+	%tmp104.sum = add i32 %tmp102, %tmp.79		; <i32> [#uses=1]
+	%line.3.0 = getelementptr i8* %base, i32 %tmp104.sum		; <i8*> [#uses=3]
+	%tmp318.upgrd.48 = load i8* %line.3.0		; <i8> [#uses=2]
+	br i1 %tmp315, label %cond_false321, label %cond_true316
 
 return.loopexit:		; preds = %cond_next280
 	br label %return.loopexit.split
@@ -512,12 +507,12 @@ return.loopexit56:		; preds = %cond_next442
 	br label %return
 
 return:		; preds = %return.loopexit56, %return.loopexit.split, %cond_false299, %cond_true197, %cond_next78, %cond_next63, %bb58, %cond_next46
-	%retval.0 = phi int [ 0, %cond_next46 ], [ -1, %bb58 ], [ -1, %cond_next63 ], [ -1, %cond_next78 ], [ 0, %cond_true197 ], [ 0, %cond_false299 ], [ 0, %return.loopexit.split ], [ 0, %return.loopexit56 ]		; <int> [#uses=1]
-	ret int %retval.0
+	%retval.0 = phi i32 [ 0, %cond_next46 ], [ -1, %bb58 ], [ -1, %cond_next63 ], [ -1, %cond_next78 ], [ 0, %cond_true197 ], [ 0, %cond_false299 ], [ 0, %return.loopexit.split ], [ 0, %return.loopexit56 ]		; <i32> [#uses=1]
+	ret i32 %retval.0
 }
 
-declare int %mem_no_fault_proc(%struct.gx_device_memory*, int, int, int, int, int)
+declare i32 @mem_no_fault_proc(%struct.gx_device_memory*, i32, i32, i32, i32, i32)
 
-declare int %mem_mono_fill_rectangle(%struct.gx_device*, int, int, int, int, uint)
+declare i32 @mem_mono_fill_rectangle(%struct.gx_device*, i32, i32, i32, i32, i32)
 
-declare int %mem_copy_mono_recover(%struct.gx_device*, ubyte*, int, int, int, int, int, int, uint, uint, int)
+declare i32 @mem_copy_mono_recover(%struct.gx_device*, i8*, i32, i32, i32, i32, i32, i32, i32, i32, i32)
diff --git a/test/Transforms/InstCombine/2006-06-28-infloop.ll b/test/Transforms/InstCombine/2006-06-28-infloop.ll
index bd1dbd009c..84e751037b 100644
--- a/test/Transforms/InstCombine/2006-06-28-infloop.ll
+++ b/test/Transforms/InstCombine/2006-06-28-infloop.ll
@@ -1,21 +1,20 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-target endian = big
-target pointersize = 32
-target triple = "powerpc-apple-darwin8"
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-implementation   ; Functions:
+target datalayout = "E-p:32:32"
+target triple = "powerpc-apple-darwin8"
 
-void %test() {
+define void @test() {
 entry:
-	%tmp = getelementptr { long, long, long, long }* null, int 0, uint 3
-	%tmp = load long* %tmp		; <long> [#uses=1]
-	%tmp8.ui = load ulong* null		; <ulong> [#uses=1]
-	%tmp8 = cast ulong %tmp8.ui to long		; <long> [#uses=1]
-	%tmp9 = and long %tmp8, %tmp		; <long> [#uses=1]
-	%sext = cast long %tmp9 to int		; <int> [#uses=1]
-	%tmp27.i = cast int %sext to long		; <long> [#uses=1]
-	tail call void %foo( uint 0, long %tmp27.i )
-	unreachable
+        %tmp = getelementptr { i64, i64, i64, i64 }* null, i32 0, i32 3         ; <i64*> [#uses=1]
+        %tmp.upgrd.1 = load i64* %tmp           ; <i64> [#uses=1]
+        %tmp8.ui = load i64* null               ; <i64> [#uses=1]
+        %tmp8 = bitcast i64 %tmp8.ui to i64             ; <i64> [#uses=1]
+        %tmp9 = and i64 %tmp8, %tmp.upgrd.1             ; <i64> [#uses=1]
+        %sext = trunc i64 %tmp9 to i32          ; <i32> [#uses=1]
+        %tmp27.i = sext i32 %sext to i64                ; <i64> [#uses=1]
+        tail call void @foo( i32 0, i64 %tmp27.i )
+        unreachable
 }
 
-declare void %foo(uint, long)
+declare void @foo(i32, i64)
+
diff --git a/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll b/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll
index 61f01ce8b7..7ed59c2fd5 100644
--- a/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll
+++ b/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll
@@ -1,28 +1,25 @@
 ; PR905
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-; END.
+; RUN: llvm-as < %s | opt -instcombine -disable-output
+	
+%RPYTHON_EXCEPTION = type { %RPYTHON_EXCEPTION_VTABLE* }
+%RPYTHON_EXCEPTION_VTABLE = type { %RPYTHON_EXCEPTION_VTABLE*, i32, i32, %RPyOpaque_RuntimeTypeInfo*, %arraytype_Char*, %functiontype_12* }
+%RPyOpaque_RuntimeTypeInfo = type opaque*
+%arraytype_Char = type { i32, [0 x i8] }
+%fixarray_array1019 = type [1019 x i8*]
+%functiontype_12 = type %RPYTHON_EXCEPTION* ()
+%functiontype_14 = type void (%structtype_pypy.rpython.memory.gc.MarkSweepGC*)
+%structtype_AddressLinkedListChunk = type { %structtype_AddressLinkedListChunk*, i32, %fixarray_array1019 }
+%structtype_exceptions.Exception = type { %RPYTHON_EXCEPTION }
+%structtype_gc_pool = type {  }
+%structtype_gc_pool_node = type { %structtype_header*, %structtype_gc_pool_node* }
+%structtype_header = type { i32, %structtype_header* }
+%structtype_pypy.rpython.memory.gc.MarkSweepGC = type { %structtype_exceptions.Exception, i32, i32, i1, %structtype_gc_pool*, i32, %structtype_header*, %structtype_header*, %structtype_gc_pool_node*, double, double }
 
-	%RPYTHON_EXCEPTION = type { %RPYTHON_EXCEPTION_VTABLE* }
-	%RPYTHON_EXCEPTION_VTABLE = type { %RPYTHON_EXCEPTION_VTABLE*, int, int, %RPyOpaque_RuntimeTypeInfo*, %arraytype_Char*, %functiontype_12* }
-	%RPyOpaque_RuntimeTypeInfo = type opaque*
-	%arraytype_Char = type { int, [0 x sbyte] }
-	%fixarray_array1019 = type [1019 x sbyte*]
-	%functiontype_12 = type %RPYTHON_EXCEPTION* ()
-	%functiontype_14 = type void (%structtype_pypy.rpython.memory.gc.MarkSweepGC*)
-	%structtype_AddressLinkedListChunk = type { %structtype_AddressLinkedListChunk*, int, %fixarray_array1019 }
-	%structtype_exceptions.Exception = type { %RPYTHON_EXCEPTION }
-	%structtype_gc_pool = type {  }
-	%structtype_gc_pool_node = type { %structtype_header*, %structtype_gc_pool_node* }
-	%structtype_header = type { int, %structtype_header* }
-	%structtype_pypy.rpython.memory.gc.MarkSweepGC = type { %structtype_exceptions.Exception, int, int, bool, %structtype_gc_pool*, int, %structtype_header*, %structtype_header*, %structtype_gc_pool_node*, double, double }
-
-implementation   ; Functions:
-
-fastcc void %pypy_MarkSweepGC.collect() {
+define fastcc void @pypy_MarkSweepGC.collect() {
 block0:
 	%v1221 = load %structtype_AddressLinkedListChunk** null		; <%structtype_AddressLinkedListChunk*> [#uses=1]
-	%v1222 = setne %structtype_AddressLinkedListChunk* %v1221, null		; <bool> [#uses=1]
-	br bool %v1222, label %block79, label %block4
+	%v1222 = icmp ne %structtype_AddressLinkedListChunk* %v1221, null		; <i1> [#uses=1]
+	br i1 %v1222, label %block79, label %block4
 
 block4:		; preds = %block0
 	ret void
@@ -32,17 +29,17 @@ block22:		; preds = %block79
 
 block67:		; preds = %block79
 	%v1459 = load %structtype_gc_pool** null		; <%structtype_gc_pool*> [#uses=1]
-	%v1460 = cast %structtype_gc_pool* %v1459 to sbyte*		; <sbyte*> [#uses=1]
-	%tmp_873 = cast sbyte* %v1460 to int		; <int> [#uses=1]
-	%tmp_874 = sub int %tmp_873, 0		; <int> [#uses=1]
-	%v1461 = cast int %tmp_874 to sbyte*		; <sbyte*> [#uses=1]
-	%v1462 = cast sbyte* %v1461 to %structtype_header*		; <%structtype_header*> [#uses=1]
-	%tmp_876 = getelementptr %structtype_header* %v1462, int 0, uint 0		; <int*> [#uses=1]
-	store int 0, int* %tmp_876
+	%v1460 = bitcast %structtype_gc_pool* %v1459 to i8*		; <i8*> [#uses=1]
+	%tmp_873 = ptrtoint i8* %v1460 to i32		; <i32> [#uses=1]
+	%tmp_874 = sub i32 %tmp_873, 0		; <i32> [#uses=1]
+	%v1461 = inttoptr i32 %tmp_874 to i8*		; <i8*> [#uses=1]
+	%v1462 = bitcast i8* %v1461 to %structtype_header*		; <%structtype_header*> [#uses=1]
+	%tmp_876 = getelementptr %structtype_header* %v1462, i32 0, i32 0		; <i32*> [#uses=1]
+	store i32 0, i32* %tmp_876
 	ret void
 
 block79:		; preds = %block0
 	%v1291 = load %structtype_gc_pool** null		; <%structtype_gc_pool*> [#uses=1]
-	%v1292 = setne %structtype_gc_pool* %v1291, null		; <bool> [#uses=1]
-	br bool %v1292, label %block67, label %block22
+	%v1292 = icmp ne %structtype_gc_pool* %v1291, null		; <i1> [#uses=1]
+	br i1 %v1292, label %block67, label %block22
 }
diff --git a/test/Transforms/InstCombine/2006-09-15-CastToBool.ll b/test/Transforms/InstCombine/2006-09-15-CastToBool.ll
index 051d91f91f..043b598c89 100644
--- a/test/Transforms/InstCombine/2006-09-15-CastToBool.ll
+++ b/test/Transforms/InstCombine/2006-09-15-CastToBool.ll
@@ -1,14 +1,14 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep and
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep and
 ; PR913
 
-int %test(int* %tmp1) {
-        %tmp.i = load int* %tmp1          ; <int> [#uses=1]
-        %tmp = cast int %tmp.i to uint            ; <uint> [#uses=1]
-        %tmp2.ui = shr uint %tmp, ubyte 5          ; <uint> [#uses=1]
-        %tmp2 = cast uint %tmp2.ui to int          ; <int> [#uses=1]
-        %tmp3 = and int %tmp2, 1                ; <int> [#uses=1]
-        %tmp3 = cast int %tmp3 to bool          ; <bool> [#uses=1]
-        %tmp34 = cast bool %tmp3 to int         ; <int> [#uses=1]
-        ret int %tmp34
+define i32 @test(i32* %tmp1) {
+        %tmp.i = load i32* %tmp1                ; <i32> [#uses=1]
+        %tmp = bitcast i32 %tmp.i to i32                ; <i32> [#uses=1]
+        %tmp2.ui = lshr i32 %tmp, 5             ; <i32> [#uses=1]
+        %tmp2 = bitcast i32 %tmp2.ui to i32             ; <i32> [#uses=1]
+        %tmp3 = and i32 %tmp2, 1                ; <i32> [#uses=1]
+        %tmp3.upgrd.1 = icmp ne i32 %tmp3, 0            ; <i1> [#uses=1]
+        %tmp34 = zext i1 %tmp3.upgrd.1 to i32           ; <i32> [#uses=1]
+        ret i32 %tmp34
 }
 
diff --git a/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll b/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll
index 58c847fb92..eca315f6f8 100644
--- a/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll
+++ b/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll
@@ -1,10 +1,10 @@
 ; The optimizer should be able to remove cast operation here.
-; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s -o - | opt -instcombine | llvm-dis | \
 ; RUN:    not grep sext.*i32
 
-bool %eq_signed_to_small_unsigned(sbyte %SB) {
-   %Y = cast sbyte %SB to uint         ; <uint> [#uses=1]
-   %C = seteq uint %Y, 17              ; <bool> [#uses=1]
-   ret bool %C
- }
+define i1 @eq_signed_to_small_unsigned(i8 %SB) {
+        %Y = sext i8 %SB to i32         ; <i32> [#uses=1]
+        %C = icmp eq i32 %Y, 17         ; <i1> [#uses=1]
+        ret i1 %C
+}
 
diff --git a/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll b/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll
index 3ada90ddc6..8678a85c46 100644
--- a/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll
+++ b/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll
@@ -1,10 +1,12 @@
 ; This test case is reduced from llvmAsmParser.cpp
 ; The optimizer should not remove the cast here.
-; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
 ; RUN:    grep sext.*i32
 
-bool %test(short %X) {
-    %A = cast short %X to uint
-    %B = setgt uint %A, 1330
-    ret bool %B
+
+define i1 @test(i16 %X) {
+        %A = sext i16 %X to i32         ; <i32> [#uses=1]
+        %B = icmp ugt i32 %A, 1330              ; <i1> [#uses=1]
+        ret i1 %B
 }
+
diff --git a/test/Transforms/InstCombine/2006-10-20-mask.ll b/test/Transforms/InstCombine/2006-10-20-mask.ll
index 8e829a7985..a5864f1c18 100644
--- a/test/Transforms/InstCombine/2006-10-20-mask.ll
+++ b/test/Transforms/InstCombine/2006-10-20-mask.ll
@@ -1,9 +1,11 @@
-; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
 ; RUN:    grep and
-ulong %foo(ulong %tmp, ulong %tmp2) {
-  %tmp = cast ulong %tmp to uint
-  %tmp2 = cast ulong %tmp2 to uint
-  %tmp3 = and uint %tmp, %tmp2
-  %tmp4 = cast uint %tmp3 to ulong
-  ret ulong %tmp4
+
+define i64 @foo(i64 %tmp, i64 %tmp2) {
+        %tmp.upgrd.1 = trunc i64 %tmp to i32            ; <i32> [#uses=1]
+        %tmp2.upgrd.2 = trunc i64 %tmp2 to i32          ; <i32> [#uses=1]
+        %tmp3 = and i32 %tmp.upgrd.1, %tmp2.upgrd.2             ; <i32> [#uses=1]
+        %tmp4 = zext i32 %tmp3 to i64           ; <i64> [#uses=1]
+        ret i64 %tmp4
 }
+
diff --git a/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll b/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll
index 2c41a37d9a..5ad0af406d 100644
--- a/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll
+++ b/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll
@@ -1,9 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep mul | count 2
 
-
-<4 x float> %test(<4 x float> %V) {
-	%Y = mul <4 x float> %V, <float 1.0, float 2.0, float 3.0, float 4.0>
-	%Z = mul <4 x float> %Y, <float 1.0, float 200000.0, float -3.0, float 4.0>
-	ret <4 x float> %Z
+define <4 x float> @test(<4 x float> %V) {
+        %Y = mul <4 x float> %V, < float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00 >                ; <<4 x float>> [#uses=1]
+        %Z = mul <4 x float> %Y, < float 1.000000e+00, float 2.000000e+05, float -3.000000e+00, float 4.000000e+00 >               ; <<4 x float>> [#uses=1]
+        ret <4 x float> %Z
 }
+
diff --git a/test/Transforms/InstCombine/2006-11-03-Memmove64.ll b/test/Transforms/InstCombine/2006-11-03-Memmove64.ll
index 550c2eb0c7..23e805a936 100644
--- a/test/Transforms/InstCombine/2006-11-03-Memmove64.ll
+++ b/test/Transforms/InstCombine/2006-11-03-Memmove64.ll
@@ -1,19 +1,16 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep memmove.i32
 ; Instcombine was trying to turn this into a memmove.i32
 
 target datalayout = "e-p:64:64"
-target endian = little
-target pointersize = 64
 target triple = "alphaev67-unknown-linux-gnu"
-%str10 = internal constant [1 x sbyte] zeroinitializer		; <[1 x sbyte]*> [#uses=1]
+@str10 = internal constant [1 x i8] zeroinitializer             ; <[1 x i8]*> [#uses=1]
 
-implementation   ; Functions:
-
-void %do_join(sbyte* %b) {
+define void @do_join(i8* %b) {
 entry:
-	call void %llvm.memmove.i64( sbyte* %b, sbyte* getelementptr ([1 x sbyte]* %str10, int 0, ulong 0), ulong 1, uint 1 )
-	ret void
+        call void @llvm.memmove.i64( i8* %b, i8* getelementptr ([1 x i8]* @str10, i32 0, i64 0), i64 1, i32 1 )
+        ret void
 }
 
-declare void %llvm.memmove.i64(sbyte*, sbyte*, ulong, uint)
+declare void @llvm.memmove.i64(i8*, i8*, i64, i32)
+
diff --git a/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll b/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll
index 1809d3ce91..8c48d4357b 100644
--- a/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll
+++ b/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll
@@ -1,7 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep lshr
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep lshr
 ; Verify this is not turned into -1.
 
-int %test(ubyte %amt) {
-  %B = lshr int -1, ubyte %amt
-  ret int %B
+define i32 @test(i8 %amt) {
+        %shift.upgrd.1 = zext i8 %amt to i32            ; <i32> [#uses=1]
+        %B = lshr i32 -1, %shift.upgrd.1                ; <i32> [#uses=1]
+        ret i32 %B
 }
+
diff --git a/test/Transforms/InstCombine/2006-11-27-XorBug.ll b/test/Transforms/InstCombine/2006-11-27-XorBug.ll
index 7cbd18eda7..631b43f61f 100644
--- a/test/Transforms/InstCombine/2006-11-27-XorBug.ll
+++ b/test/Transforms/InstCombine/2006-11-27-XorBug.ll
@@ -1,12 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep and.*32
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep and.*32
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep or.*153
 ; PR1014
 
-int %test(int %tmp1) {
-        %ovm = and int %tmp1, 32                ; <int> [#uses=1]
-        %ov3 = add int %ovm, 145                ; <int> [#uses=2]
-        %ov110 = xor int %ov3, 153
-        ret int %ov110
+define i32 @test(i32 %tmp1) {
+        %ovm = and i32 %tmp1, 32                ; <i32> [#uses=1]
+        %ov3 = add i32 %ovm, 145                ; <i32> [#uses=1]
+        %ov110 = xor i32 %ov3, 153              ; <i32> [#uses=1]
+        ret i32 %ov110
 }
 
diff --git a/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll b/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll
index e2cdf31e2f..60ee503279 100644
--- a/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll
+++ b/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll
@@ -1,9 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep sub
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep add
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep sub
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep add
 
-<4 x float> %test(<4 x float> %tmp26, <4 x float> %tmp53) {
-  ; (X+Y)-Y != X for fp vectors.
-  %tmp64 = add <4 x float> %tmp26, %tmp53
-  %tmp75 = sub <4 x float> %tmp64, %tmp53
-  ret <4 x float> %tmp75
+define <4 x float> @test(<4 x float> %tmp26, <4 x float> %tmp53) {
+        ; (X+Y)-Y != X for fp vectors.
+        %tmp64 = add <4 x float> %tmp26, %tmp53         ; <<4 x float>> [#uses=1]
+        %tmp75 = sub <4 x float> %tmp64, %tmp53         ; <<4 x float>> [#uses=1]
+        ret <4 x float> %tmp75
 }
diff --git a/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll b/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll
index 4661dfe55b..2c3313efa2 100644
--- a/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll
+++ b/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll
@@ -1,13 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep zext
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep zext
 
 ; Never merge these two conversions, even though it's possible: this is
 ; significantly more expensive than the two conversions on some targets
 ; and it causes libgcc to be compile __fixunsdfdi into a recursive 
 ; function.
-
-
-long %test(double %D) {
-	%A = fptoui double %D to uint
-	%B = zext uint %A to long
-	ret long %B
+define i64 @test(double %D) {
+        %A = fptoui double %D to i32            ; <i32> [#uses=1]
+        %B = zext i32 %A to i64         ; <i64> [#uses=1]
+        ret i64 %B
 }
+
diff --git a/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll b/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll
index db4b9e289f..ddfb88c7bf 100644
--- a/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll
+++ b/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll
@@ -1,17 +1,18 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep {%bothcond =}
-bool %Doit_bb(int %i.0) {
-bb:             ; preds = %newFuncRoot
-        %tmp = setgt int %i.0, 0             ; <bool> [#uses=1]
-        %tmp.not = xor bool %tmp, true          ; <bool> [#uses=1]
-        %tmp2 = setgt int %i.0, 8            ; <bool> [#uses=1]
-        %bothcond = or bool %tmp.not, %tmp2             ; <bool> [#uses=1]
-        br bool %bothcond, label %exitTrue, label %exitFalse
 
-exitTrue:             ; preds = %bb
-        ret bool true
+define i1 @Doit_bb(i32 %i.0) {
+bb:
+        %tmp = icmp sgt i32 %i.0, 0             ; <i1> [#uses=1]
+        %tmp.not = xor i1 %tmp, true            ; <i1> [#uses=1]
+        %tmp2 = icmp sgt i32 %i.0, 8            ; <i1> [#uses=1]
+        %bothcond = or i1 %tmp.not, %tmp2               ; <i1> [#uses=1]
+        br i1 %bothcond, label %exitTrue, label %exitFalse
 
-exitFalse:            ; preds = %bb
-        ret bool false
+exitTrue:               ; preds = %bb
+        ret i1 true
 
+exitFalse:              ; preds = %bb
+        ret i1 false
 }
+
diff --git a/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll b/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll
index 0965623409..16dbd2196e 100644
--- a/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll
+++ b/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll
@@ -1,57 +1,50 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep {icmp sgt}
-; END.
-
-; ModuleID = 'visible.bc'
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-	%struct.point = type { int, int }
-
-implementation   ; Functions:
+	%struct.point = type { i32, i32 }
 
-int %visible(int %direction, long %p1.0, long %p2.0, long %p3.0) {
+define i32 @visible(i32 %direction, i64 %p1.0, i64 %p2.0, i64 %p3.0) {
 entry:
 	%p1_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
 	%p2_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
 	%p3_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
-	"alloca point" = bitcast int 0 to int		; <int> [#uses=0]
-	%tmp = bitcast %struct.point* %p1_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp = getelementptr { long }* %tmp, uint 0, uint 0		; <long*> [#uses=1]
-	store long %p1.0, long* %tmp
-	%tmp1 = bitcast %struct.point* %p2_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp2 = getelementptr { long }* %tmp1, uint 0, uint 0		; <long*> [#uses=1]
-	store long %p2.0, long* %tmp2
-	%tmp3 = bitcast %struct.point* %p3_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp4 = getelementptr { long }* %tmp3, uint 0, uint 0		; <long*> [#uses=1]
-	store long %p3.0, long* %tmp4
-	%tmp = seteq int %direction, 0		; <bool> [#uses=1]
-	%tmp5 = bitcast %struct.point* %p1_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp6 = getelementptr { long }* %tmp5, uint 0, uint 0		; <long*> [#uses=1]
-	%tmp = load long* %tmp6		; <long> [#uses=1]
-	%tmp7 = bitcast %struct.point* %p2_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp8 = getelementptr { long }* %tmp7, uint 0, uint 0		; <long*> [#uses=1]
-	%tmp9 = load long* %tmp8		; <long> [#uses=1]
-	%tmp10 = bitcast %struct.point* %p3_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp11 = getelementptr { long }* %tmp10, uint 0, uint 0		; <long*> [#uses=1]
-	%tmp12 = load long* %tmp11		; <long> [#uses=1]
-	%tmp13 = call int %determinant( long %tmp, long %tmp9, long %tmp12 )		; <int> [#uses=2]
-	br bool %tmp, label %cond_true, label %cond_false
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	%tmp = bitcast %struct.point* %p1_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp.upgrd.1 = getelementptr { i64 }* %tmp, i64 0, i32 0		; <i64*> [#uses=1]
+	store i64 %p1.0, i64* %tmp.upgrd.1
+	%tmp1 = bitcast %struct.point* %p2_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp2 = getelementptr { i64 }* %tmp1, i64 0, i32 0		; <i64*> [#uses=1]
+	store i64 %p2.0, i64* %tmp2
+	%tmp3 = bitcast %struct.point* %p3_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp4 = getelementptr { i64 }* %tmp3, i64 0, i32 0		; <i64*> [#uses=1]
+	store i64 %p3.0, i64* %tmp4
+	%tmp.upgrd.2 = icmp eq i32 %direction, 0		; <i1> [#uses=1]
+	%tmp5 = bitcast %struct.point* %p1_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp6 = getelementptr { i64 }* %tmp5, i64 0, i32 0		; <i64*> [#uses=1]
+	%tmp.upgrd.3 = load i64* %tmp6		; <i64> [#uses=1]
+	%tmp7 = bitcast %struct.point* %p2_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp8 = getelementptr { i64 }* %tmp7, i64 0, i32 0		; <i64*> [#uses=1]
+	%tmp9 = load i64* %tmp8		; <i64> [#uses=1]
+	%tmp10 = bitcast %struct.point* %p3_addr to { i64 }*		; <{ i64 }*> [#uses=1]
+	%tmp11 = getelementptr { i64 }* %tmp10, i64 0, i32 0		; <i64*> [#uses=1]
+	%tmp12 = load i64* %tmp11		; <i64> [#uses=1]
+	%tmp13 = call i32 @determinant( i64 %tmp.upgrd.3, i64 %tmp9, i64 %tmp12 )		; <i32> [#uses=2]
+	br i1 %tmp.upgrd.2, label %cond_true, label %cond_false
 
 cond_true:		; preds = %entry
-	%tmp14 = setlt int %tmp13, 0		; <bool> [#uses=1]
-	%tmp14 = zext bool %tmp14 to int		; <int> [#uses=1]
+	%tmp14 = icmp slt i32 %tmp13, 0		; <i1> [#uses=1]
+	%tmp14.upgrd.4 = zext i1 %tmp14 to i32		; <i32> [#uses=1]
 	br label %return
 
 cond_false:		; preds = %entry
-	%tmp26 = setgt int %tmp13, 0		; <bool> [#uses=1]
-	%tmp26 = zext bool %tmp26 to int		; <int> [#uses=1]
+	%tmp26 = icmp sgt i32 %tmp13, 0		; <i1> [#uses=1]
+	%tmp26.upgrd.5 = zext i1 %tmp26 to i32		; <i32> [#uses=1]
 	br label %return
 
 return:		; preds = %cond_false, %cond_true
-	%retval.0 = phi int [ %tmp14, %cond_true ], [ %tmp26, %cond_false ]		; <int> [#uses=1]
-	ret int %retval.0
+	%retval.0 = phi i32 [ %tmp14.upgrd.4, %cond_true ], [ %tmp26.upgrd.5, %cond_false ]		; <i32> [#uses=1]
+	ret i32 %retval.0
 }
 
-declare int %determinant(long, long, long)
+declare i32 @determinant(i64, i64, i64)
diff --git a/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll b/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll
index 466fa60c08..cc36d64dfa 100644
--- a/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll
+++ b/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll
@@ -1,44 +1,40 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep select
-; END.
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep select
 
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-	%struct.point = type { int, int }
+        %struct.point = type { i32, i32 }
 
-implementation   ; Functions:
-
-int %visible(int %direction, long %p1.0, long %p2.0, long %p3.0) {
+define i32 @visible(i32 %direction, i64 %p1.0, i64 %p2.0, i64 %p3.0) {
 entry:
-	%p1_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
-	%p2_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
-	%p3_addr = alloca %struct.point		; <%struct.point*> [#uses=2]
-	%tmp = bitcast %struct.point* %p1_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp = getelementptr { long }* %tmp, int 0, uint 0		; <long*> [#uses=1]
-	store long %p1.0, long* %tmp
-	%tmp1 = bitcast %struct.point* %p2_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp2 = getelementptr { long }* %tmp1, int 0, uint 0		; <long*> [#uses=1]
-	store long %p2.0, long* %tmp2
-	%tmp3 = bitcast %struct.point* %p3_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp4 = getelementptr { long }* %tmp3, int 0, uint 0		; <long*> [#uses=1]
-	store long %p3.0, long* %tmp4
-	%tmp = seteq int %direction, 0		; <bool> [#uses=1]
-	%tmp5 = bitcast %struct.point* %p1_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp6 = getelementptr { long }* %tmp5, int 0, uint 0		; <long*> [#uses=1]
-	%tmp = load long* %tmp6		; <long> [#uses=1]
-	%tmp7 = bitcast %struct.point* %p2_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp8 = getelementptr { long }* %tmp7, int 0, uint 0		; <long*> [#uses=1]
-	%tmp9 = load long* %tmp8		; <long> [#uses=1]
-	%tmp10 = bitcast %struct.point* %p3_addr to { long }*		; <{ long }*> [#uses=1]
-	%tmp11 = getelementptr { long }* %tmp10, int 0, uint 0		; <long*> [#uses=1]
-	%tmp12 = load long* %tmp11		; <long> [#uses=1]
-	%tmp13 = call int %determinant( long %tmp, long %tmp9, long %tmp12 )		; <int> [#uses=2]
-	%tmp14 = setlt int %tmp13, 0		; <bool> [#uses=1]
-	%tmp26 = setgt int %tmp13, 0		; <bool> [#uses=1]
-	%retval.0.in = select bool %tmp, bool %tmp14, bool %tmp26		; <bool> [#uses=1]
-	%retval.0 = zext bool %retval.0.in to int		; <int> [#uses=1]
-	ret int %retval.0
+        %p1_addr = alloca %struct.point         ; <%struct.point*> [#uses=2]
+        %p2_addr = alloca %struct.point         ; <%struct.point*> [#uses=2]
+        %p3_addr = alloca %struct.point         ; <%struct.point*> [#uses=2]
+        %tmp = bitcast %struct.point* %p1_addr to { i64 }*              ; <{ i64 }*> [#uses=1]
+        %tmp.upgrd.1 = getelementptr { i64 }* %tmp, i32 0, i32 0                ; <i64*> [#uses=1]
+        store i64 %p1.0, i64* %tmp.upgrd.1
+        %tmp1 = bitcast %struct.point* %p2_addr to { i64 }*             ; <{ i64 }*> [#uses=1]
+        %tmp2 = getelementptr { i64 }* %tmp1, i32 0, i32 0              ; <i64*> [#uses=1]
+        store i64 %p2.0, i64* %tmp2
+        %tmp3 = bitcast %struct.point* %p3_addr to { i64 }*             ; <{ i64 }*> [#uses=1]
+        %tmp4 = getelementptr { i64 }* %tmp3, i32 0, i32 0              ; <i64*> [#uses=1]
+        store i64 %p3.0, i64* %tmp4
+        %tmp.upgrd.2 = icmp eq i32 %direction, 0                ; <i1> [#uses=1]
+        %tmp5 = bitcast %struct.point* %p1_addr to { i64 }*             ; <{ i64 }*> [#uses=1]
+        %tmp6 = getelementptr { i64 }* %tmp5, i32 0, i32 0              ; <i64*> [#uses=1]
+        %tmp.upgrd.3 = load i64* %tmp6          ; <i64> [#uses=1]
+        %tmp7 = bitcast %struct.point* %p2_addr to { i64 }*             ; <{ i64 }*> [#uses=1]
+        %tmp8 = getelementptr { i64 }* %tmp7, i32 0, i32 0              ; <i64*> [#uses=1]
+        %tmp9 = load i64* %tmp8         ; <i64> [#uses=1]
+        %tmp10 = bitcast %struct.point* %p3_addr to { i64 }*            ; <{ i64 }*> [#uses=1]
+        %tmp11 = getelementptr { i64 }* %tmp10, i32 0, i32 0            ; <i64*> [#uses=1]
+        %tmp12 = load i64* %tmp11               ; <i64> [#uses=1]
+        %tmp13 = call i32 @determinant( i64 %tmp.upgrd.3, i64 %tmp9, i64 %tmp12 )         ; <i32> [#uses=2]
+        %tmp14 = icmp slt i32 %tmp13, 0         ; <i1> [#uses=1]
+        %tmp26 = icmp sgt i32 %tmp13, 0         ; <i1> [#uses=1]
+        %retval.0.in = select i1 %tmp.upgrd.2, i1 %tmp14, i1 %tmp26             ; <i1> [#uses=1]
+        %retval.0 = zext i1 %retval.0.in to i32         ; <i32> [#uses=1]
+        ret i32 %retval.0
 }
 
-declare int %determinant(long, long, long)
+declare i32 @determinant(i64, i64, i64)
+
diff --git a/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll b/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll
index 1343a4f5d0..08ebe6ad3a 100644
--- a/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll
+++ b/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll
@@ -1,167 +1,161 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
-; RUN:    grep -v {icmp ult int}
-; END.
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
+; RUN:    grep -v {icmp ult i32}
 
-; ModuleID = 'good.bc'
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-        %struct.edgeBox = type { short, short, short, short, short, short }
-%qsz = external global int              ; <int*> [#uses=12]
-%thresh = external global int           ; <int*> [#uses=2]
-%mthresh = external global int          ; <int*> [#uses=1]
+	%struct.edgeBox = type { i16, i16, i16, i16, i16, i16 }
+@qsz = external global i32		; <i32*> [#uses=12]
+@thresh = external global i32		; <i32*> [#uses=2]
+@mthresh = external global i32		; <i32*> [#uses=1]
 
-implementation   ; Functions:
-
-int %qsorte(sbyte* %base, int %n, int %size) {
+define i32 @qsorte(i8* %base, i32 %n, i32 %size) {
 entry:
-        %tmp = setgt int %n, 1          ; <bool> [#uses=1]
-        br bool %tmp, label %cond_next, label %return
-
-cond_next:              ; preds = %entry
-        store int %size, int* %qsz
-        %tmp3 = shl int %size, ubyte 2          ; <int> [#uses=1]
-        store int %tmp3, int* %thresh
-        %tmp4 = load int* %qsz          ; <int> [#uses=1]
-        %tmp5 = mul int %tmp4, 6                ; <int> [#uses=1]
-        store int %tmp5, int* %mthresh
-        %tmp6 = load int* %qsz          ; <int> [#uses=1]
-        %tmp8 = mul int %tmp6, %n               ; <int> [#uses=1]
-        %tmp9 = getelementptr sbyte* %base, int %tmp8           ; <sbyte*> [#uses=3]
-        %tmp11 = setgt int %n, 3                ; <bool> [#uses=1]
-        br bool %tmp11, label %cond_true12, label %bb30
-
-cond_true12:            ; preds = %cond_next
-        %tmp156 = call int %qste( sbyte* %base, sbyte* %tmp9 )          ; <int> [#uses=0]
-        %tmp16 = load int* %thresh              ; <int> [#uses=1]
-        %tmp18 = getelementptr sbyte* %base, int %tmp16         ; <sbyte*> [#uses=2]
-        %tmp3117 = load int* %qsz               ; <int> [#uses=1]
-        %tmp3318 = getelementptr sbyte* %base, int %tmp3117             ; <sbyte*> [#uses=2]
-        %tmp3621 = setlt sbyte* %tmp3318, %tmp18                ; <bool> [#uses=1]
-        br bool %tmp3621, label %bb, label %bb37
-
-bb:             ; preds = %bb30, %cond_true12
-        %hi.0.0 = phi sbyte* [ %tmp18, %cond_true12 ], [ %hi.0, %bb30 ]         ; <sbyte*> [#uses=4]
-        %j.1.0 = phi sbyte* [ %base, %cond_true12 ], [ %j.1, %bb30 ]            ; <sbyte*> [#uses=4]
-        %tmp33.0 = phi sbyte* [ %tmp3318, %cond_true12 ], [ %tmp33, %bb30 ]             ; <sbyte*> [#uses=6]
-        %tmp3 = bitcast sbyte* %j.1.0 to %struct.edgeBox*               ; <%struct.edgeBox*> [#uses=1]
-        %tmp4 = bitcast sbyte* %tmp33.0 to %struct.edgeBox*             ; <%struct.edgeBox*> [#uses=1]
-        %tmp255 = call int %comparee( %struct.edgeBox* %tmp3, %struct.edgeBox* %tmp4 )          ; <int> [#uses=1]
-        %tmp26 = setgt int %tmp255, 0           ; <bool> [#uses=1]
-        br bool %tmp26, label %cond_true27, label %bb30
-
-cond_true27:            ; preds = %bb
-        br label %bb30
-
-bb30:           ; preds = %cond_true27, %bb, %cond_next
-        %hi.0.3 = phi sbyte* [ %hi.0.0, %cond_true27 ], [ %hi.0.0, %bb ], [ undef, %cond_next ]         ; <sbyte*> [#uses=0]
-        %j.1.3 = phi sbyte* [ %j.1.0, %cond_true27 ], [ %j.1.0, %bb ], [ undef, %cond_next ]            ; <sbyte*> [#uses=0]
-        %tmp33.3 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ undef, %cond_next ]              ; <sbyte*> [#uses=0]
-        %hi.0 = phi sbyte* [ %tmp9, %cond_next ], [ %hi.0.0, %bb ], [ %hi.0.0, %cond_true27 ]           ; <sbyte*> [#uses=2]
-        %lo.1 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ %base, %cond_next ]         ; <sbyte*> [#uses=1]
-        %j.1 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %j.1.0, %bb ], [ %base, %cond_next ]            ; <sbyte*> [#uses=2]
-        %tmp31 = load int* %qsz         ; <int> [#uses=1]
-        %tmp33 = getelementptr sbyte* %lo.1, int %tmp31         ; <sbyte*> [#uses=2]
-        %tmp36 = setlt sbyte* %tmp33, %hi.0             ; <bool> [#uses=1]
-        br bool %tmp36, label %bb, label %bb37
-
-bb37:           ; preds = %bb30, %cond_true12
-        %j.1.1 = phi sbyte* [ %j.1, %bb30 ], [ %base, %cond_true12 ]            ; <sbyte*> [#uses=4]
-        %tmp40 = seteq sbyte* %j.1.1, %base             ; <bool> [#uses=1]
-        br bool %tmp40, label %bb115, label %cond_true41
-
-cond_true41:            ; preds = %bb37
-        %tmp43 = load int* %qsz         ; <int> [#uses=1]
-        %tmp45 = getelementptr sbyte* %base, int %tmp43         ; <sbyte*> [#uses=2]
-        %tmp6030 = setlt sbyte* %base, %tmp45           ; <bool> [#uses=1]
-        br bool %tmp6030, label %bb46, label %bb115
-
-bb46:           ; preds = %bb46, %cond_true41
-        %j.2.0 = phi sbyte* [ %j.1.1, %cond_true41 ], [ %tmp52, %bb46 ]         ; <sbyte*> [#uses=3]
-        %i.2.0 = phi sbyte* [ %base, %cond_true41 ], [ %tmp56, %bb46 ]          ; <sbyte*> [#uses=3]
-        %tmp = load sbyte* %j.2.0               ; <sbyte> [#uses=2]
-        %tmp49 = load sbyte* %i.2.0             ; <sbyte> [#uses=1]
-        store sbyte %tmp49, sbyte* %j.2.0
-        %tmp52 = getelementptr sbyte* %j.2.0, int 1             ; <sbyte*> [#uses=2]
-        store sbyte %tmp, sbyte* %i.2.0
-        %tmp56 = getelementptr sbyte* %i.2.0, int 1             ; <sbyte*> [#uses=3]
-        %tmp60 = setlt sbyte* %tmp56, %tmp45            ; <bool> [#uses=1]
-        br bool %tmp60, label %bb46, label %bb115
-
-bb66:           ; preds = %bb115, %bb66
-        %hi.3 = phi sbyte* [ %tmp118, %bb115 ], [ %tmp70, %bb66 ]               ; <sbyte*> [#uses=2]
-        %tmp67 = load int* %qsz         ; <int> [#uses=2]
-        %tmp68 = sub int 0, %tmp67              ; <int> [#uses=1]
-        %tmp70 = getelementptr sbyte* %hi.3, int %tmp68         ; <sbyte*> [#uses=2]
-        %tmp = bitcast sbyte* %tmp70 to %struct.edgeBox*                ; <%struct.edgeBox*> [#uses=1]
-        %tmp1 = bitcast sbyte* %tmp118 to %struct.edgeBox*              ; <%struct.edgeBox*> [#uses=1]
-        %tmp732 = call int %comparee( %struct.edgeBox* %tmp, %struct.edgeBox* %tmp1 )           ; <int> [#uses=1]
-        %tmp74 = setgt int %tmp732, 0           ; <bool> [#uses=1]
-        br bool %tmp74, label %bb66, label %bb75
-
-bb75:           ; preds = %bb66
-        %tmp76 = load int* %qsz         ; <int> [#uses=1]
-        %tmp70.sum = sub int %tmp76, %tmp67             ; <int> [#uses=1]
-        %tmp78 = getelementptr sbyte* %hi.3, int %tmp70.sum             ; <sbyte*> [#uses=3]
-        %tmp81 = seteq sbyte* %tmp78, %tmp118           ; <bool> [#uses=1]
-        br bool %tmp81, label %bb115, label %cond_true82
-
-cond_true82:            ; preds = %bb75
-        %tmp83 = load int* %qsz         ; <int> [#uses=1]
-        %tmp118.sum = add int %tmp116, %tmp83           ; <int> [#uses=1]
-        %tmp85 = getelementptr sbyte* %min.1, int %tmp118.sum           ; <sbyte*> [#uses=1]
-        %tmp10937 = getelementptr sbyte* %tmp85, int -1         ; <sbyte*> [#uses=3]
-        %tmp11239 = setlt sbyte* %tmp10937, %tmp118             ; <bool> [#uses=1]
-        br bool %tmp11239, label %bb115, label %bb86
-
-bb86:           ; preds = %bb104, %cond_true82
-        %tmp109.0 = phi sbyte* [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ]         ; <sbyte*> [#uses=5]
-        %i.5.2 = phi sbyte* [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ]                ; <sbyte*> [#uses=0]
-        %tmp100.2 = phi sbyte* [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ]               ; <sbyte*> [#uses=0]
-        %tmp88 = load sbyte* %tmp109.0          ; <sbyte> [#uses=2]
-        %tmp9746 = load int* %qsz               ; <int> [#uses=1]
-        %tmp9847 = sub int 0, %tmp9746          ; <int> [#uses=1]
-        %tmp10048 = getelementptr sbyte* %tmp109.0, int %tmp9847                ; <sbyte*> [#uses=3]
-        %tmp10350 = setlt sbyte* %tmp10048, %tmp78              ; <bool> [#uses=1]
-        br bool %tmp10350, label %bb104, label %bb91
-
-bb91:           ; preds = %bb91, %bb86
-        %i.5.0 = phi sbyte* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ]          ; <sbyte*> [#uses=1]
-        %tmp100.0 = phi sbyte* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ]         ; <sbyte*> [#uses=4]
-        %tmp93 = load sbyte* %tmp100.0          ; <sbyte> [#uses=1]
-        store sbyte %tmp93, sbyte* %i.5.0
-        %tmp97 = load int* %qsz         ; <int> [#uses=1]
-        %tmp98 = sub int 0, %tmp97              ; <int> [#uses=1]
-        %tmp100 = getelementptr sbyte* %tmp100.0, int %tmp98            ; <sbyte*> [#uses=3]
-        %tmp103 = setlt sbyte* %tmp100, %tmp78          ; <bool> [#uses=1]
-        br bool %tmp103, label %bb104, label %bb91
-
-bb104:          ; preds = %bb91, %bb86
-        %i.5.1 = phi sbyte* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ]          ; <sbyte*> [#uses=4]
-        %tmp100.1 = phi sbyte* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ]         ; <sbyte*> [#uses=3]
-        store sbyte %tmp88, sbyte* %i.5.1
-        %tmp109 = getelementptr sbyte* %tmp109.0, int -1                ; <sbyte*> [#uses=3]
-        %tmp112 = setlt sbyte* %tmp109, %tmp118         ; <bool> [#uses=1]
-        br bool %tmp112, label %bb115, label %bb86
-
-bb115:          ; preds = %bb104, %cond_true82, %bb75, %bb46, %cond_true41, %bb37
-        %tmp109.1 = phi sbyte* [ undef, %bb37 ], [ %tmp109.1, %bb75 ], [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]              ; <sbyte*> [#uses=1]
-        %i.5.3 = phi sbyte* [ undef, %bb37 ], [ %i.5.3, %bb75 ], [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]                ; <sbyte*> [#uses=3]
-        %tmp100.3 = phi sbyte* [ undef, %bb37 ], [ %tmp100.3, %bb75 ], [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]            ; <sbyte*> [#uses=3]
-        %min.1 = phi sbyte* [ %tmp118, %bb104 ], [ %tmp118, %bb75 ], [ %base, %bb37 ], [ %base, %bb46 ], [ %base, %cond_true41 ], [ %tmp118, %cond_true82 ]             ; <sbyte*> [#uses=2]
-        %j.5 = phi sbyte* [ %tmp100.1, %bb104 ], [ %j.5, %bb75 ], [ %tmp52, %bb46 ], [ %j.1.1, %bb37 ], [ %j.1.1, %cond_true41 ], [ %j.5, %cond_true82 ]                ; <sbyte*> [#uses=2]
-        %i.4 = phi sbyte* [ %i.5.1, %bb104 ], [ %i.4, %bb75 ], [ %tmp56, %bb46 ], [ undef, %bb37 ], [ %base, %cond_true41 ], [ %i.4, %cond_true82 ]             ; <sbyte*> [#uses=2]
-        %c.4 = phi sbyte [ %tmp88, %bb104 ], [ %c.4, %bb75 ], [ %tmp, %bb46 ], [ undef, %bb37 ], [ undef, %cond_true41 ], [ %c.4, %cond_true82 ]                ; <sbyte> [#uses=2]
-        %tmp116 = load int* %qsz                ; <int> [#uses=2]
-        %tmp118 = getelementptr sbyte* %min.1, int %tmp116              ; <sbyte*> [#uses=9]
-        %tmp122 = setlt sbyte* %tmp118, %tmp9           ; <bool> [#uses=1]
-        br bool %tmp122, label %bb66, label %return
-
-return:         ; preds = %bb115, %entry
-        ret int undef
+	%tmp = icmp sgt i32 %n, 1		; <i1> [#uses=1]
+	br i1 %tmp, label %cond_next, label %return
+
+cond_next:		; preds = %entry
+	store i32 %size, i32* @qsz
+	%tmp3 = shl i32 %size, 2		; <i32> [#uses=1]
+	store i32 %tmp3, i32* @thresh
+	%tmp4 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp5 = mul i32 %tmp4, 6		; <i32> [#uses=1]
+	store i32 %tmp5, i32* @mthresh
+	%tmp6 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp8 = mul i32 %tmp6, %n		; <i32> [#uses=1]
+	%tmp9 = getelementptr i8* %base, i32 %tmp8		; <i8*> [#uses=3]
+	%tmp11 = icmp sgt i32 %n, 3		; <i1> [#uses=1]
+	br i1 %tmp11, label %cond_true12, label %bb30
+
+cond_true12:		; preds = %cond_next
+	%tmp156 = call i32 @qste( i8* %base, i8* %tmp9 )		; <i32> [#uses=0]
+	%tmp16 = load i32* @thresh		; <i32> [#uses=1]
+	%tmp18 = getelementptr i8* %base, i32 %tmp16		; <i8*> [#uses=2]
+	%tmp3117 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp3318 = getelementptr i8* %base, i32 %tmp3117		; <i8*> [#uses=2]
+	%tmp3621 = icmp ult i8* %tmp3318, %tmp18		; <i1> [#uses=1]
+	br i1 %tmp3621, label %bb, label %bb37
+
+bb:		; preds = %bb30, %cond_true12
+	%hi.0.0 = phi i8* [ %tmp18, %cond_true12 ], [ %hi.0, %bb30 ]		; <i8*> [#uses=4]
+	%j.1.0 = phi i8* [ %base, %cond_true12 ], [ %j.1, %bb30 ]		; <i8*> [#uses=4]
+	%tmp33.0 = phi i8* [ %tmp3318, %cond_true12 ], [ %tmp33, %bb30 ]		; <i8*> [#uses=6]
+	%tmp3.upgrd.1 = bitcast i8* %j.1.0 to %struct.edgeBox*		; <%struct.edgeBox*> [#uses=1]
+	%tmp4.upgrd.2 = bitcast i8* %tmp33.0 to %struct.edgeBox*		; <%struct.edgeBox*> [#uses=1]
+	%tmp255 = call i32 @comparee( %struct.edgeBox* %tmp3.upgrd.1, %struct.edgeBox* %tmp4.upgrd.2 )		; <i32> [#uses=1]
+	%tmp26 = icmp sgt i32 %tmp255, 0		; <i1> [#uses=1]
+	br i1 %tmp26, label %cond_true27, label %bb30
+
+cond_true27:		; preds = %bb
+	br label %bb30
+
+bb30:		; preds = %cond_true27, %bb, %cond_next
+	%hi.0.3 = phi i8* [ %hi.0.0, %cond_true27 ], [ %hi.0.0, %bb ], [ undef, %cond_next ]		; <i8*> [#uses=0]
+	%j.1.3 = phi i8* [ %j.1.0, %cond_true27 ], [ %j.1.0, %bb ], [ undef, %cond_next ]		; <i8*> [#uses=0]
+	%tmp33.3 = phi i8* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ undef, %cond_next ]		; <i8*> [#uses=0]
+	%hi.0 = phi i8* [ %tmp9, %cond_next ], [ %hi.0.0, %bb ], [ %hi.0.0, %cond_true27 ]		; <i8*> [#uses=2]
+	%lo.1 = phi i8* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ %base, %cond_next ]		; <i8*> [#uses=1]
+	%j.1 = phi i8* [ %tmp33.0, %cond_true27 ], [ %j.1.0, %bb ], [ %base, %cond_next ]		; <i8*> [#uses=2]
+	%tmp31 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp33 = getelementptr i8* %lo.1, i32 %tmp31		; <i8*> [#uses=2]
+	%tmp36 = icmp ult i8* %tmp33, %hi.0		; <i1> [#uses=1]
+	br i1 %tmp36, label %bb, label %bb37
+
+bb37:		; preds = %bb30, %cond_true12
+	%j.1.1 = phi i8* [ %j.1, %bb30 ], [ %base, %cond_true12 ]		; <i8*> [#uses=4]
+	%tmp40 = icmp eq i8* %j.1.1, %base		; <i1> [#uses=1]
+	br i1 %tmp40, label %bb115, label %cond_true41
+
+cond_true41:		; preds = %bb37
+	%tmp43 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp45 = getelementptr i8* %base, i32 %tmp43		; <i8*> [#uses=2]
+	%tmp6030 = icmp ult i8* %base, %tmp45		; <i1> [#uses=1]
+	br i1 %tmp6030, label %bb46, label %bb115
+
+bb46:		; preds = %bb46, %cond_true41
+	%j.2.0 = phi i8* [ %j.1.1, %cond_true41 ], [ %tmp52, %bb46 ]		; <i8*> [#uses=3]
+	%i.2.0 = phi i8* [ %base, %cond_true41 ], [ %tmp56, %bb46 ]		; <i8*> [#uses=3]
+	%tmp.upgrd.3 = load i8* %j.2.0		; <i8> [#uses=2]
+	%tmp49 = load i8* %i.2.0		; <i8> [#uses=1]
+	store i8 %tmp49, i8* %j.2.0
+	%tmp52 = getelementptr i8* %j.2.0, i32 1		; <i8*> [#uses=2]
+	store i8 %tmp.upgrd.3, i8* %i.2.0
+	%tmp56 = getelementptr i8* %i.2.0, i32 1		; <i8*> [#uses=3]
+	%tmp60 = icmp ult i8* %tmp56, %tmp45		; <i1> [#uses=1]
+	br i1 %tmp60, label %bb46, label %bb115
+
+bb66:		; preds = %bb115, %bb66
+	%hi.3 = phi i8* [ %tmp118, %bb115 ], [ %tmp70, %bb66 ]		; <i8*> [#uses=2]
+	%tmp67 = load i32* @qsz		; <i32> [#uses=2]
+	%tmp68 = sub i32 0, %tmp67		; <i32> [#uses=1]
+	%tmp70 = getelementptr i8* %hi.3, i32 %tmp68		; <i8*> [#uses=2]
+	%tmp.upgrd.4 = bitcast i8* %tmp70 to %struct.edgeBox*		; <%struct.edgeBox*> [#uses=1]
+	%tmp1 = bitcast i8* %tmp118 to %struct.edgeBox*		; <%struct.edgeBox*> [#uses=1]
+	%tmp732 = call i32 @comparee( %struct.edgeBox* %tmp.upgrd.4, %struct.edgeBox* %tmp1 )		; <i32> [#uses=1]
+	%tmp74 = icmp sgt i32 %tmp732, 0		; <i1> [#uses=1]
+	br i1 %tmp74, label %bb66, label %bb75
+
+bb75:		; preds = %bb66
+	%tmp76 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp70.sum = sub i32 %tmp76, %tmp67		; <i32> [#uses=1]
+	%tmp78 = getelementptr i8* %hi.3, i32 %tmp70.sum		; <i8*> [#uses=3]
+	%tmp81 = icmp eq i8* %tmp78, %tmp118		; <i1> [#uses=1]
+	br i1 %tmp81, label %bb115, label %cond_true82
+
+cond_true82:		; preds = %bb75
+	%tmp83 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp118.sum = add i32 %tmp116, %tmp83		; <i32> [#uses=1]
+	%tmp85 = getelementptr i8* %min.1, i32 %tmp118.sum		; <i8*> [#uses=1]
+	%tmp10937 = getelementptr i8* %tmp85, i32 -1		; <i8*> [#uses=3]
+	%tmp11239 = icmp ult i8* %tmp10937, %tmp118		; <i1> [#uses=1]
+	br i1 %tmp11239, label %bb115, label %bb86
+
+bb86:		; preds = %bb104, %cond_true82
+	%tmp109.0 = phi i8* [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ]		; <i8*> [#uses=5]
+	%i.5.2 = phi i8* [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ]		; <i8*> [#uses=0]
+	%tmp100.2 = phi i8* [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ]		; <i8*> [#uses=0]
+	%tmp88 = load i8* %tmp109.0		; <i8> [#uses=2]
+	%tmp9746 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp9847 = sub i32 0, %tmp9746		; <i32> [#uses=1]
+	%tmp10048 = getelementptr i8* %tmp109.0, i32 %tmp9847		; <i8*> [#uses=3]
+	%tmp10350 = icmp ult i8* %tmp10048, %tmp78		; <i1> [#uses=1]
+	br i1 %tmp10350, label %bb104, label %bb91
+
+bb91:		; preds = %bb91, %bb86
+	%i.5.0 = phi i8* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ]		; <i8*> [#uses=1]
+	%tmp100.0 = phi i8* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ]		; <i8*> [#uses=4]
+	%tmp93 = load i8* %tmp100.0		; <i8> [#uses=1]
+	store i8 %tmp93, i8* %i.5.0
+	%tmp97 = load i32* @qsz		; <i32> [#uses=1]
+	%tmp98 = sub i32 0, %tmp97		; <i32> [#uses=1]
+	%tmp100 = getelementptr i8* %tmp100.0, i32 %tmp98		; <i8*> [#uses=3]
+	%tmp103 = icmp ult i8* %tmp100, %tmp78		; <i1> [#uses=1]
+	br i1 %tmp103, label %bb104, label %bb91
+
+bb104:		; preds = %bb91, %bb86
+	%i.5.1 = phi i8* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ]		; <i8*> [#uses=4]
+	%tmp100.1 = phi i8* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ]		; <i8*> [#uses=3]
+	store i8 %tmp88, i8* %i.5.1
+	%tmp109 = getelementptr i8* %tmp109.0, i32 -1		; <i8*> [#uses=3]
+	%tmp112 = icmp ult i8* %tmp109, %tmp118		; <i1> [#uses=1]
+	br i1 %tmp112, label %bb115, label %bb86
+
+bb115:		; preds = %bb104, %cond_true82, %bb75, %bb46, %cond_true41, %bb37
+	%tmp109.1 = phi i8* [ undef, %bb37 ], [ %tmp109.1, %bb75 ], [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]		; <i8*> [#uses=1]
+	%i.5.3 = phi i8* [ undef, %bb37 ], [ %i.5.3, %bb75 ], [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]		; <i8*> [#uses=3]
+	%tmp100.3 = phi i8* [ undef, %bb37 ], [ %tmp100.3, %bb75 ], [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ]		; <i8*> [#uses=3]
+	%min.1 = phi i8* [ %tmp118, %bb104 ], [ %tmp118, %bb75 ], [ %base, %bb37 ], [ %base, %bb46 ], [ %base, %cond_true41 ], [ %tmp118, %cond_true82 ]		; <i8*> [#uses=2]
+	%j.5 = phi i8* [ %tmp100.1, %bb104 ], [ %j.5, %bb75 ], [ %tmp52, %bb46 ], [ %j.1.1, %bb37 ], [ %j.1.1, %cond_true41 ], [ %j.5, %cond_true82 ]		; <i8*> [#uses=2]
+	%i.4 = phi i8* [ %i.5.1, %bb104 ], [ %i.4, %bb75 ], [ %tmp56, %bb46 ], [ undef, %bb37 ], [ %base, %cond_true41 ], [ %i.4, %cond_true82 ]		; <i8*> [#uses=2]
+	%c.4 = phi i8 [ %tmp88, %bb104 ], [ %c.4, %bb75 ], [ %tmp.upgrd.3, %bb46 ], [ undef, %bb37 ], [ undef, %cond_true41 ], [ %c.4, %cond_true82 ]		; <i8> [#uses=2]
+	%tmp116 = load i32* @qsz		; <i32> [#uses=2]
+	%tmp118 = getelementptr i8* %min.1, i32 %tmp116		; <i8*> [#uses=9]
+	%tmp122 = icmp ult i8* %tmp118, %tmp9		; <i1> [#uses=1]
+	br i1 %tmp122, label %bb66, label %return
+
+return:		; preds = %bb115, %entry
+	ret i32 undef
 }
 
-declare int %qste(sbyte*, sbyte*)
+declare i32 @qste(i8*, i8*)
 
-declare int %comparee(%struct.edgeBox*, %struct.edgeBox*)
+declare i32 @comparee(%struct.edgeBox*, %struct.edgeBox*)
diff --git a/test/Transforms/InstCombine/2006-12-15-Range-Test.ll b/test/Transforms/InstCombine/2006-12-15-Range-Test.ll
index 4767558616..585257c779 100644
--- a/test/Transforms/InstCombine/2006-12-15-Range-Test.ll
+++ b/test/Transforms/InstCombine/2006-12-15-Range-Test.ll
@@ -1,36 +1,30 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep icmp | count 1
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep {icmp ugt} | count 1
-; END.
 
-; ModuleID = 'bugpoint-tooptimize.bc'
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-%r = external global [17 x int]         ; <[17 x int]*> [#uses=1]
+@r = external global [17 x i32]         ; <[17 x i32]*> [#uses=1]
 
-implementation   ; Functions:
-
-bool %print_pgm_cond_true(int %tmp12.reload, int* %tmp16.out) {
+define i1 @print_pgm_cond_true(i32 %tmp12.reload, i32* %tmp16.out) {
 newFuncRoot:
         br label %cond_true
 
 bb27.exitStub:          ; preds = %cond_true
-        store int %tmp16, int* %tmp16.out
-        ret bool true
+        store i32 %tmp16, i32* %tmp16.out
+        ret i1 true
 
 cond_next23.exitStub:           ; preds = %cond_true
-        store int %tmp16, int* %tmp16.out
-        ret bool false
+        store i32 %tmp16, i32* %tmp16.out
+        ret i1 false
 
 cond_true:              ; preds = %newFuncRoot
-        %tmp15 = getelementptr [17 x int]* %r, int 0, int %tmp12.reload         ; <int*> [#uses=1]
-        %tmp16 = load int* %tmp15               ; <int> [#uses=4]
-        %tmp18 = icmp slt int %tmp16, -31               ; <bool> [#uses=1]
-        %tmp21 = icmp sgt int %tmp16, 31                ; <bool> [#uses=1]
-        %bothcond = or bool %tmp18, %tmp21              ; <bool> [#uses=1]
-        br bool %bothcond, label %bb27.exitStub, label %cond_next23.exitStub
+        %tmp15 = getelementptr [17 x i32]* @r, i32 0, i32 %tmp12.reload         ; <i32*> [#uses=1]
+        %tmp16 = load i32* %tmp15               ; <i32> [#uses=4]
+        %tmp18 = icmp slt i32 %tmp16, -31               ; <i1> [#uses=1]
+        %tmp21 = icmp sgt i32 %tmp16, 31                ; <i1> [#uses=1]
+        %bothcond = or i1 %tmp18, %tmp21                ; <i1> [#uses=1]
+        br i1 %bothcond, label %bb27.exitStub, label %cond_next23.exitStub
 }
 
diff --git a/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll b/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll
index 044b9451c5..e653aa1e2c 100644
--- a/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll
+++ b/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll
@@ -1,31 +1,25 @@
 ; For PR1065. This causes an assertion in instcombine if a select with two cmp
 ; operands is encountered.
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output
-; END.
+; RUN: llvm-as < %s | opt -instcombine -disable-output
 
-; ModuleID = 'PR1065.bc'
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-	%struct.internal_state = type { int }
-	%struct.mng_data = type { uint, sbyte*, uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, uint, uint, sbyte, uint, uint, uint, uint, ushort, ushort, ushort, sbyte, sbyte, double, double, double, sbyte, sbyte, sbyte, sbyte, uint, uint, uint, uint, int, sbyte, int, int, sbyte*, sbyte* (uint)*, void (sbyte*, uint)*, void (sbyte*, sbyte*, uint)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*, sbyte*, uint, uint*)*, sbyte (%struct.mng_data*, sbyte*, uint, uint*)*, sbyte (%struct.mng_data*, int, sbyte, int, uint, int, int, sbyte*)*, sbyte (%struct.mng_data*, int, int, sbyte*)*, sbyte (%struct.mng_data*, uint, uint)*, sbyte (%struct.mng_data*, ubyte, sbyte*, sbyte*, sbyte*, sbyte*)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*, sbyte*)*, sbyte (%struct.mng_data*, sbyte*)*, sbyte (%struct.mng_data*, uint, uint)*, sbyte (%struct.mng_data*, int, uint, sbyte*)*, sbyte (%struct.mng_data*, ubyte, ubyte, uint, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint, uint, uint, uint)*, uint (%struct.mng_data*)*, sbyte (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint, uint, uint, uint, uint, uint, uint, uint)*, sbyte (%struct.mng_data*, ubyte)*, sbyte (%struct.mng_data*, uint, sbyte*)*, sbyte (%struct.mng_data*, uint, sbyte, sbyte*)*, sbyte, int, uint, sbyte*, sbyte*, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, uint, uint, ubyte, ubyte, ubyte, ubyte, ubyte, uint, sbyte, sbyte, sbyte, uint, ubyte*, uint, ubyte*, uint, sbyte, ubyte, sbyte, uint, ubyte*, ubyte*, uint, uint, ubyte*, ubyte*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, sbyte, sbyte, int, uint, ubyte*, sbyte, sbyte, uint, uint, uint, uint, uint, uint, sbyte, sbyte, sbyte, sbyte, int, int, sbyte*, uint, uint, uint, sbyte, sbyte, uint, uint, uint, uint, sbyte, sbyte, ubyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, uint, sbyte*, sbyte*, sbyte*, uint, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct.mng_savedata*, uint, uint, uint, uint, sbyte, int, int, int, int, int, int, int, int, int, int, int, int, uint, uint, uint, uint, ubyte*, ubyte*, ubyte*, sbyte, sbyte, int, int, int, int, int, int, int, int, int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, [256 x ubyte], double, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, ushort, sbyte, ubyte, sbyte, ubyte, sbyte, int, int, sbyte, int, int, int, int, ushort, ushort, ushort, ubyte, ushort, ubyte, int, int, uint, uint, ubyte, uint, uint, sbyte, int, int, int, int, ubyte, uint, uint, sbyte, int, int, int, int, uint, sbyte, uint, ubyte, ushort, ushort, ushort, short, uint, [256 x %struct.mng_palette8e], uint, [256 x ubyte], uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, sbyte*, ushort, ushort, ushort, sbyte*, ubyte, ubyte, uint, uint, uint, uint, sbyte, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, sbyte*, ubyte, ubyte, ubyte, uint, sbyte*, sbyte*, ushort, ushort, ushort, ushort, int, int, sbyte*, %struct.z_stream, int, int, int, int, int, uint, sbyte, sbyte, [256 x uint], sbyte }
-	%struct.mng_palette8e = type { ubyte, ubyte, ubyte }
-	%struct.mng_pushdata = type { sbyte*, sbyte*, uint, sbyte, ubyte*, uint }
-	%struct.mng_savedata = type { sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ushort, ushort, ushort, ubyte, ushort, ubyte, ubyte, uint, uint, sbyte, int, int, int, int, uint, [256 x %struct.mng_palette8e], uint, [256 x ubyte], uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, sbyte*, ushort, ushort, ushort }
-	%struct.z_stream = type { ubyte*, uint, uint, ubyte*, uint, uint, sbyte*, %struct.internal_state*, sbyte* (sbyte*, uint, uint)*, void (sbyte*, sbyte*)*, sbyte*, int, uint, uint }
+	%struct.internal_state = type { i32 }
+	%struct.mng_data = type { i32, i8*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i32, i32, i32, i8, i32, i32, i32, i32, i16, i16, i16, i8, i8, double, double, double, i8, i8, i8, i8, i32, i32, i32, i32, i32, i8, i32, i32, i8*, i8* (i32)*, void (i8*, i32)*, void (i8*, i8*, i32)*, i8 (%struct.mng_data*)*, i8 (%struct.mng_data*)*, i8 (%struct.mng_data*, i8*, i32, i32*)*, i8 (%struct.mng_data*, i8*, i32, i32*)*, i8 (%struct.mng_data*, i32, i8, i32, i32, i32, i32, i8*)*, i8 (%struct.mng_data*, i32, i32, i8*)*, i8 (%struct.mng_data*, i32, i32)*, i8 (%struct.mng_data*, i8, i8*, i8*, i8*, i8*)*, i8 (%struct.mng_data*)*, i8 (%struct.mng_data*, i8*)*, i8 (%struct.mng_data*, i8*)*, i8 (%struct.mng_data*, i32, i32)*, i8 (%struct.mng_data*, i32, i32, i8*)*, i8 (%struct.mng_data*, i8, i8, i32, i32)*, i8* (%struct.mng_data*, i32)*, i8* (%struct.mng_data*, i32)*, i8* (%struct.mng_data*, i32)*, i8 (%struct.mng_data*, i32, i32, i32, i32)*, i32 (%struct.mng_data*)*, i8 (%struct.mng_data*, i32)*, i8 (%struct.mng_data*, i32)*, i8 (%struct.mng_data*, i32, i32, i32, i32, i32, i32, i32, i32)*, i8 (%struct.mng_data*, i8)*, i8 (%struct.mng_data*, i32, i8*)*, i8 (%struct.mng_data*, i32, i8, i8*)*, i8, i32, i32, i8*, i8*, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i32, i32, i8, i8, i8, i8, i8, i32, i8, i8, i8, i32, i8*, i32, i8*, i32, i8, i8, i8, i32, i8*, i8*, i32, i32, i8*, i8*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, i8, i8, i32, i32, i8*, i8, i8, i32, i32, i32, i32, i32, i32, i8, i8, i8, i8, i32, i32, i8*, i32, i32, i32, i8, i8, i32, i32, i32, i32, i8, i8, i8, i8, i8, i8, i8, i8, i8, i32, i8*, i8*, i8*, i32, i8*, i8*, i8*, i8*, i8*, %struct.mng_savedata*, i32, i32, i32, i32, i8, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8*, i8*, i8*, i8, i8, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8*, i8*, i8*, i8*, i8*, i8*, [256 x i8], double, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, i16, i8, i8, i8, i8, i8, i32, i32, i8, i32, i32, i32, i32, i16, i16, i16, i8, i16, i8, i32, i32, i32, i32, i8, i32, i32, i8, i32, i32, i32, i32, i8, i32, i32, i8, i32, i32, i32, i32, i32, i8, i32, i8, i16, i16, i16, i16, i32, [256 x %struct.mng_palette8e], i32, [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i32, i8*, i16, i16, i16, i8*, i8, i8, i32, i32, i32, i32, i8, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, i8*, i8, i8, i8, i32, i8*, i8*, i16, i16, i16, i16, i32, i32, i8*, %struct.z_stream, i32, i32, i32, i32, i32, i32, i8, i8, [256 x i32], i8 }
+	%struct.mng_palette8e = type { i8, i8, i8 }
+	%struct.mng_pushdata = type { i8*, i8*, i32, i8, i8*, i32 }
+	%struct.mng_savedata = type { i8, i8, i8, i8, i8, i8, i8, i16, i16, i16, i8, i16, i8, i8, i32, i32, i8, i32, i32, i32, i32, i32, [256 x %struct.mng_palette8e], i32, [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i32, i8*, i16, i16, i16 }
+	%struct.z_stream = type { i8*, i32, i32, i8*, i32, i32, i8*, %struct.internal_state*, i8* (i8*, i32, i32)*, void (i8*, i8*)*, i8*, i32, i32, i32 }
 
-implementation   ; Functions:
-
-void %mng_write_basi() {
+define void @mng_write_basi() {
 entry:
-	%tmp = load ubyte* null		; <ubyte> [#uses=1]
-	%tmp = icmp ugt ubyte %tmp, 8		; <bool> [#uses=1]
-	%tmp = load ushort* null		; <ushort> [#uses=2]
-	%tmp3 = icmp eq ushort %tmp, 255		; <bool> [#uses=1]
-	%tmp7 = icmp eq ushort %tmp, -1		; <bool> [#uses=1]
-	%bOpaque.0.in = select bool %tmp, bool %tmp7, bool %tmp3		; <bool> [#uses=1]
-	br bool %bOpaque.0.in, label %cond_next90, label %bb95
+	%tmp = load i8* null		; <i8> [#uses=1]
+	%tmp.upgrd.1 = icmp ugt i8 %tmp, 8		; <i1> [#uses=1]
+	%tmp.upgrd.2 = load i16* null		; <i16> [#uses=2]
+	%tmp3 = icmp eq i16 %tmp.upgrd.2, 255		; <i1> [#uses=1]
+	%tmp7 = icmp eq i16 %tmp.upgrd.2, -1		; <i1> [#uses=1]
+	%bOpaque.0.in = select i1 %tmp.upgrd.1, i1 %tmp7, i1 %tmp3		; <i1> [#uses=1]
+	br i1 %bOpaque.0.in, label %cond_next90, label %bb95
 
 cond_next90:		; preds = %entry
 	ret void
diff --git a/test/Transforms/InstCombine/2007-02-07-PointerCast.ll b/test/Transforms/InstCombine/2007-02-07-PointerCast.ll
index f38b4c1d46..ce9eb3c69d 100644
--- a/test/Transforms/InstCombine/2007-02-07-PointerCast.ll
+++ b/test/Transforms/InstCombine/2007-02-07-PointerCast.ll
@@ -1,4 +1,4 @@
-;RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep zext
+;RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep zext
 
 ; Make sure the uint isn't removed.  Instcombine in llvm 1.9 was dropping the 
 ; uint cast which was causing a sign extend. This only affected code with 
@@ -6,21 +6,17 @@
 ; compile a kernel though...
 
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
+@str = internal constant [6 x i8] c"%llx\0A\00"         ; <[6 x i8]*> [#uses=1]
 
-%str = internal constant [6 x sbyte] c"%llx\0A\00"
+declare i32 @printf(i8*, ...)
 
-implementation   ; Functions:
-
-declare int %printf(sbyte*, ...)
-
-int %main(int %x, sbyte** %a) {
+define i32 @main(i32 %x, i8** %a) {
 entry:
-        %tmp = getelementptr [6 x sbyte]* %str, int 0, uint 0 
-        %tmp1 = load sbyte** %a
-	%tmp2 = cast sbyte* %tmp1 to uint		; <uint> [#uses=1]
-	%tmp3 = cast uint %tmp2 to long		; <long> [#uses=1]
-        %tmp = call int (sbyte*, ...)* %printf( sbyte* %tmp, long %tmp3 )
-        ret int 0
+        %tmp = getelementptr [6 x i8]* @str, i32 0, i64 0               ; <i8*> [#uses=1]
+        %tmp1 = load i8** %a            ; <i8*> [#uses=1]
+        %tmp2 = ptrtoint i8* %tmp1 to i32               ; <i32> [#uses=1]
+        %tmp3 = zext i32 %tmp2 to i64           ; <i64> [#uses=1]
+        %tmp.upgrd.1 = call i32 (i8*, ...)* @printf( i8* %tmp, i64 %tmp3 )              ; <i32> [#uses=0]
+        ret i32 0
 }
+
diff --git a/test/Transforms/InstCombine/narrow.ll b/test/Transforms/InstCombine/narrow.ll
index 02d7e31b8a..41106e759c 100644
--- a/test/Transforms/InstCombine/narrow.ll
+++ b/test/Transforms/InstCombine/narrow.ll
@@ -1,17 +1,18 @@
 ; This file contains various testcases that check to see that instcombine
 ; is narrowing computations when possible.
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep {ret i1 false}
 
 ; test1 - Eliminating the casts in this testcase (by narrowing the AND
 ; operation) allows instcombine to realize the function always returns false.
 ;
-bool %test1(int %A, int %B) {
-        %C1 = setlt int %A, %B
-        %ELIM1 = zext bool %C1 to uint
-        %C2 = setgt int %A, %B
-        %ELIM2 = zext bool %C2 to uint
-        %C3 = and uint %ELIM1, %ELIM2
-        %ELIM3 = trunc uint %C3 to bool
-        ret bool %ELIM3
+define i1 @test1(i32 %A, i32 %B) {
+        %C1 = icmp slt i32 %A, %B               ; <i1> [#uses=1]
+        %ELIM1 = zext i1 %C1 to i32             ; <i32> [#uses=1]
+        %C2 = icmp sgt i32 %A, %B               ; <i1> [#uses=1]
+        %ELIM2 = zext i1 %C2 to i32             ; <i32> [#uses=1]
+        %C3 = and i32 %ELIM1, %ELIM2            ; <i32> [#uses=1]
+        %ELIM3 = trunc i32 %C3 to i1            ; <i1> [#uses=1]
+        ret i1 %ELIM3
 }
+
diff --git a/test/Transforms/InstCombine/not.ll b/test/Transforms/InstCombine/not.ll
index 3e85692500..757e1de940 100644
--- a/test/Transforms/InstCombine/not.ll
+++ b/test/Transforms/InstCombine/not.ll
@@ -1,45 +1,44 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep xor
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep xor
 
-implementation
-
-int %test1(int %A) {
-	%B = xor int %A, -1
-	%C = xor int %B, -1
-	ret int %C
+define i32 @test1(i32 %A) {
+        %B = xor i32 %A, -1             ; <i32> [#uses=1]
+        %C = xor i32 %B, -1             ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-bool %test2(int %A, int %B) {
-	%cond = setle int %A, %B     ; Can change into setge
-	%Ret = xor bool %cond, true
-	ret bool %Ret
+define i1 @test2(i32 %A, i32 %B) {
+        ; Can change into setge
+        %cond = icmp sle i32 %A, %B             ; <i1> [#uses=1]
+        %Ret = xor i1 %cond, true               ; <i1> [#uses=1]
+        ret i1 %Ret
 }
 
-
 ; Test that demorgans law can be instcombined
-int %test3(int %A, int %B) {
-	%a = xor int %A, -1
-	%b = xor int %B, -1
-	%c = and int %a, %b
-	%d = xor int %c, -1
-	ret int %d
+define i32 @test3(i32 %A, i32 %B) {
+        %a = xor i32 %A, -1             ; <i32> [#uses=1]
+        %b = xor i32 %B, -1             ; <i32> [#uses=1]
+        %c = and i32 %a, %b             ; <i32> [#uses=1]
+        %d = xor i32 %c, -1             ; <i32> [#uses=1]
+        ret i32 %d
 }
 
 ; Test that demorgens law can work with constants
-int %test4(int %A, int %B) {
-	%a = xor int %A, -1
-	%c = and int %a, 5    ; 5 = ~c2
-	%d = xor int %c, -1
-	ret int %d
+define i32 @test4(i32 %A, i32 %B) {
+        %a = xor i32 %A, -1             ; <i32> [#uses=1]
+        %c = and i32 %a, 5              ; <i32> [#uses=1]
+        %d = xor i32 %c, -1             ; <i32> [#uses=1]
+        ret i32 %d
 }
 
 ; test the mirror of demorgans law...
-int %test5(int %A, int %B) {
-	%a = xor int %A, -1
-	%b = xor int %B, -1
-	%c = or int %a, %b
-	%d = xor int %c, -1
-	ret int %d
+define i32 @test5(i32 %A, i32 %B) {
+        %a = xor i32 %A, -1             ; <i32> [#uses=1]
+        %b = xor i32 %B, -1             ; <i32> [#uses=1]
+        %c = or i32 %a, %b              ; <i32> [#uses=1]
+        %d = xor i32 %c, -1             ; <i32> [#uses=1]
+        ret i32 %d
 }
+
diff --git a/test/Transforms/InstCombine/or.ll b/test/Transforms/InstCombine/or.ll
index 3fc225a302..e70fb1c4e0 100644
--- a/test/Transforms/InstCombine/or.ll
+++ b/test/Transforms/InstCombine/or.ll
@@ -1,158 +1,171 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep -v xor | not grep {or }
 ; END.
 
-implementation
-
-int %test1(int %A) {
-	%B = or int %A, 0
-	ret int %B
+define i32 @test1(i32 %A) {
+        %B = or i32 %A, 0               ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test2(int %A) {
-	%B = or int %A, -1
-	ret int %B
+define i32 @test2(i32 %A) {
+        %B = or i32 %A, -1              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-ubyte %test2a(ubyte %A) {
-	%B = or ubyte %A, 255
-	ret ubyte %B
+define i8 @test2a(i8 %A) {
+        %B = or i8 %A, -1               ; <i8> [#uses=1]
+        ret i8 %B
 }
 
-bool %test3(bool %A) {
-	%B = or bool %A, false
-	ret bool %B
+define i1 @test3(i1 %A) {
+        %B = or i1 %A, false            ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test4(bool %A) {
-	%B = or bool %A, true
-	ret bool %B
+define i1 @test4(i1 %A) {
+        %B = or i1 %A, true             ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test5(bool %A) {
-	%B = or bool %A, %A
-	ret bool %B
+define i1 @test5(i1 %A) {
+        %B = or i1 %A, %A               ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-int %test6(int %A) {
-	%B = or int %A, %A
-	ret int %B
+define i32 @test6(i32 %A) {
+        %B = or i32 %A, %A              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test7(int %A) {    ; A | ~A == -1
-        %NotA = xor int -1, %A
-        %B = or int %A, %NotA
-        ret int %B
+; A | ~A == -1
+define i32 @test7(i32 %A) {
+        %NotA = xor i32 -1, %A          ; <i32> [#uses=1]
+        %B = or i32 %A, %NotA           ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-ubyte %test8(ubyte %A) {
-	%B = or ubyte %A, 254
-	%C = or ubyte %B, 1
-	ret ubyte %C
+define i8 @test8(i8 %A) {
+        %B = or i8 %A, -2               ; <i8> [#uses=1]
+        %C = or i8 %B, 1                ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-ubyte %test9(ubyte %A, ubyte %B) {  ; Test that (A|c1)|(B|c2) == (A|B)|(c1|c2)
-	%C = or ubyte %A, 1
-	%D = or ubyte %B, 254
-	%E = or ubyte %C, %D
-	ret ubyte %E
+; Test that (A|c1)|(B|c2) == (A|B)|(c1|c2)
+define i8 @test9(i8 %A, i8 %B) {
+        %C = or i8 %A, 1                ; <i8> [#uses=1]
+        %D = or i8 %B, -2               ; <i8> [#uses=1]
+        %E = or i8 %C, %D               ; <i8> [#uses=1]
+        ret i8 %E
 }
 
-ubyte %test10(ubyte %A) {
-	%B = or ubyte %A, 1
-	%C = and ubyte %B, 254
-	%D = or ubyte %C, 254  ; (X & C1) | C2 --> (X | C2) & (C1|C2)
-	ret ubyte %D
+define i8 @test10(i8 %A) {
+        %B = or i8 %A, 1                ; <i8> [#uses=1]
+        %C = and i8 %B, -2              ; <i8> [#uses=1]
+        ; (X & C1) | C2 --> (X | C2) & (C1|C2)
+        %D = or i8 %C, -2               ; <i8> [#uses=1]
+        ret i8 %D
 }
 
-ubyte %test11(ubyte %A) {
-	%B = or ubyte %A, 254
-	%C = xor ubyte %B, 13
-	%D = or ubyte %C, 1    ; (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
-	%E = xor ubyte %D, 12
-	ret ubyte %E
+define i8 @test11(i8 %A) {
+        %B = or i8 %A, -2               ; <i8> [#uses=1]
+        %C = xor i8 %B, 13              ; <i8> [#uses=1]
+        ; (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
+        %D = or i8 %C, 1                ; <i8> [#uses=1]
+        %E = xor i8 %D, 12              ; <i8> [#uses=1]
+        ret i8 %E
 }
 
-uint %test12(uint %A) {
-	%B = or uint %A, 4     ; Should be eliminated
-	%C = and uint %B, 8
-	ret uint %C
+define i32 @test12(i32 %A) {
+        ; Should be eliminated
+        %B = or i32 %A, 4               ; <i32> [#uses=1]
+        %C = and i32 %B, 8              ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-uint %test13(uint %A) {
-	%B = or uint %A, 12
-	%C = and uint %B, 8    ; Always equal to 8
-	ret uint %C 
+define i32 @test13(i32 %A) {
+        %B = or i32 %A, 12              ; <i32> [#uses=1]
+        ; Always equal to 8
+        %C = and i32 %B, 8              ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-bool %test14(uint %A, uint %B) {
-	%C1 = setlt uint %A, %B
-	%C2 = setgt uint %A, %B
-	%D = or bool %C1, %C2      ; (A < B) | (A > B) === A != B
-	ret bool %D
+define i1 @test14(i32 %A, i32 %B) {
+        %C1 = icmp ult i32 %A, %B               ; <i1> [#uses=1]
+        %C2 = icmp ugt i32 %A, %B               ; <i1> [#uses=1]
+        ; (A < B) | (A > B) === A != B
+        %D = or i1 %C1, %C2             ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-bool %test15(uint %A, uint %B) {
-        %C1 = setlt uint %A, %B
-        %C2 = seteq uint %A, %B
-        %D = or bool %C1, %C2      ; (A < B) | (A == B) === A <= B
-        ret bool %D
+define i1 @test15(i32 %A, i32 %B) {
+        %C1 = icmp ult i32 %A, %B               ; <i1> [#uses=1]
+        %C2 = icmp eq i32 %A, %B                ; <i1> [#uses=1]
+        ; (A < B) | (A == B) === A <= B
+        %D = or i1 %C1, %C2             ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-int %test16(int %A) {
-	%B = and int %A, 1
-	%C = and int %A, -2       ; -2 = ~1
-	%D = or int %B, %C        ; %D = and int %B, -1 == %B
-	ret int %D
+define i32 @test16(i32 %A) {
+        %B = and i32 %A, 1              ; <i32> [#uses=1]
+        ; -2 = ~1
+        %C = and i32 %A, -2             ; <i32> [#uses=1]
+        ; %D = and int %B, -1 == %B
+        %D = or i32 %B, %C              ; <i32> [#uses=1]
+        ret i32 %D
 }
 
-int %test17(int %A) {
-	%B = and int %A, 1
-	%C = and int %A, 4
-	%D = or int %B, %C        ; %D = and int %B, 5
-	ret int %D
+define i32 @test17(i32 %A) {
+        %B = and i32 %A, 1              ; <i32> [#uses=1]
+        %C = and i32 %A, 4              ; <i32> [#uses=1]
+        ; %D = and int %B, 5
+        %D = or i32 %B, %C              ; <i32> [#uses=1]
+        ret i32 %D
 }
 
-bool %test18(int %A) {
-        %B = setge int %A, 100
-        %C = setlt int %A, 50
-        %D = or bool %B, %C   ;; (A-50) >u 50
-        ret bool %D
+define i1 @test18(i32 %A) {
+        %B = icmp sge i32 %A, 100               ; <i1> [#uses=1]
+        %C = icmp slt i32 %A, 50                ; <i1> [#uses=1]
+        ;; (A-50) >u 50
+        %D = or i1 %B, %C               ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-bool %test19(int %A) {
-        %B = seteq int %A, 50
-        %C = seteq int %A, 51
-        %D = or bool %B, %C   ;; (A-50) < 2
-        ret bool %D
+define i1 @test19(i32 %A) {
+        %B = icmp eq i32 %A, 50         ; <i1> [#uses=1]
+        %C = icmp eq i32 %A, 51         ; <i1> [#uses=1]
+        ;; (A-50) < 2
+        %D = or i1 %B, %C               ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-int %test20(int %x) {
-	%y = and int %x, 123
-	%z = or int %y, %x
-	ret int %z
+define i32 @test20(i32 %x) {
+        %y = and i32 %x, 123            ; <i32> [#uses=1]
+        %z = or i32 %y, %x              ; <i32> [#uses=1]
+        ret i32 %z
 }
 
-uint %test21(uint %tmp.1) {
-        %tmp.1.mask1 = add uint %tmp.1, 2
-        %tmp.3 = and uint %tmp.1.mask1, 4294967294
-        %tmp.5 = and uint %tmp.1, 1
-        %tmp.6 = or uint %tmp.5, %tmp.3   ;; add tmp.1, 2
-	ret uint %tmp.6
+define i32 @test21(i32 %tmp.1) {
+        %tmp.1.mask1 = add i32 %tmp.1, 2                ; <i32> [#uses=1]
+        %tmp.3 = and i32 %tmp.1.mask1, -2               ; <i32> [#uses=1]
+        %tmp.5 = and i32 %tmp.1, 1              ; <i32> [#uses=1]
+        ;; add tmp.1, 2
+        %tmp.6 = or i32 %tmp.5, %tmp.3          ; <i32> [#uses=1]
+        ret i32 %tmp.6
 }
 
-int %test22(int %B) {
-        %ELIM41 = and int %B, 1         ; <int> [#uses=1]
-        %ELIM7 = and int %B, -2         ; <int> [#uses=1]
-        %ELIM5 = or int %ELIM41, %ELIM7         ; <int> [#uses=1]
-	ret int %ELIM5
-}
+define i32 @test22(i32 %B) {
+        %ELIM41 = and i32 %B, 1         ; <i32> [#uses=1]
+        %ELIM7 = and i32 %B, -2         ; <i32> [#uses=1]
+        %ELIM5 = or i32 %ELIM41, %ELIM7         ; <i32> [#uses=1]
+        ret i32 %ELIM5
+}
 
-ushort %test23(ushort %A) {
-        %B = shr ushort %A, ubyte 1
-        %C = or ushort %B, 32768       ;; fold or into xor
-        %D = xor ushort %C, 8193
-        ret ushort %D
+define i16 @test23(i16 %A) {
+        %B = lshr i16 %A, 1             ; <i16> [#uses=1]
+        ;; fold or into xor
+        %C = or i16 %B, -32768          ; <i16> [#uses=1]
+        %D = xor i16 %C, 8193           ; <i16> [#uses=1]
+        ret i16 %D
 }
diff --git a/test/Transforms/InstCombine/phi.ll b/test/Transforms/InstCombine/phi.ll
index a51e90ed0d..6f0ef6b549 100644
--- a/test/Transforms/InstCombine/phi.ll
+++ b/test/Transforms/InstCombine/phi.ll
@@ -1,78 +1,101 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep phi
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep phi
 ; END.
 
-implementation
+define i32 @test1(i32 %A, i1 %b) {
+BB0:
+        br i1 %b, label %BB1, label %BB2
+
+BB1:            ; preds = %BB0
+        ; Combine away one argument PHI nodes
+        %B = phi i32 [ %A, %BB0 ]               ; <i32> [#uses=1]
+        ret i32 %B
 
-int %test1(int %A, bool %b) {
-BB0:    br bool %b, label %BB1, label %BB2
-BB1:
-        %B = phi int [%A, %BB0]     ; Combine away one argument PHI nodes
-        ret int %B
-BB2:
-        ret int %A
+BB2:            ; preds = %BB0
+        ret i32 %A
 }
 
-int %test2(int %A, bool %b) {
-BB0:    br bool %b, label %BB1, label %BB2
-BB1:
-	br label %BB2
-BB2:
-        %B = phi int [%A, %BB0], [%A, %BB1]     ; Combine away PHI nodes with same values
-        ret int %B
+define i32 @test2(i32 %A, i1 %b) {
+BB0:
+        br i1 %b, label %BB1, label %BB2
+
+BB1:            ; preds = %BB0
+        br label %BB2
+
+BB2:            ; preds = %BB1, %BB0
+        ; Combine away PHI nodes with same values
+        %B = phi i32 [ %A, %BB0 ], [ %A, %BB1 ]         ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test3(int %A, bool %b) {
-BB0: br label %Loop
+define i32 @test3(i32 %A, i1 %b) {
+BB0:
+        br label %Loop
+
+Loop:           ; preds = %Loop, %BB0
+        ; PHI has same value always.
+        %B = phi i32 [ %A, %BB0 ], [ %B, %Loop ]                ; <i32> [#uses=2]
+        br i1 %b, label %Loop, label %Exit
 
-Loop:
-	%B = phi int [%A, %BB0], [%B, %Loop]    ; PHI has same value always.
-	br bool %b, label %Loop, label %Exit
-Exit:
-	ret int %B
+Exit:           ; preds = %Loop
+        ret i32 %B
 }
 
-int %test4(bool %b) {
-BB0:  ret int 7                                 ; Loop is unreachable
+define i32 @test4(i1 %b) {
+BB0:
+        ; Loop is unreachable
+        ret i32 7
 
-Loop:
-        %B = phi int [%B, %L2], [%B, %Loop]     ; PHI has same value always.
-        br bool %b, label %L2, label %Loop
-L2:
-	br label %Loop
+Loop:           ; preds = %L2, %Loop
+        ; PHI has same value always.
+        %B = phi i32 [ %B, %L2 ], [ %B, %Loop ]         ; <i32> [#uses=2]
+        br i1 %b, label %L2, label %Loop
+
+L2:             ; preds = %Loop
+        br label %Loop
 }
 
-int %test5(int %A, bool %b) {
-BB0: br label %Loop
+define i32 @test5(i32 %A, i1 %b) {
+BB0:
+        br label %Loop
+
+Loop:           ; preds = %Loop, %BB0
+        ; PHI has same value always.
+        %B = phi i32 [ %A, %BB0 ], [ undef, %Loop ]             ; <i32> [#uses=1]
+        br i1 %b, label %Loop, label %Exit
 
-Loop:
-        %B = phi int [%A, %BB0], [undef, %Loop]    ; PHI has same value always.
-        br bool %b, label %Loop, label %Exit
-Exit:
-        ret int %B
+Exit:           ; preds = %Loop
+        ret i32 %B
 }
 
-uint %test6(int %A, bool %b) {
+define i32 @test6(i32 %A, i1 %b) {
 BB0:
-        %X = cast int %A to uint
-        br bool %b, label %BB1, label %BB2
-BB1:
-        %Y = cast int %A to uint
+        %X = bitcast i32 %A to i32              ; <i32> [#uses=1]
+        br i1 %b, label %BB1, label %BB2
+
+BB1:            ; preds = %BB0
+        %Y = bitcast i32 %A to i32              ; <i32> [#uses=1]
         br label %BB2
-BB2:
-        %B = phi uint [%X, %BB0], [%Y, %BB1] ;; Suck casts into phi
-        ret uint %B
+
+BB2:            ; preds = %BB1, %BB0
+        ;; Suck casts into phi
+        %B = phi i32 [ %X, %BB0 ], [ %Y, %BB1 ]         ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test7(int %A, bool %b) {
-BB0: br label %Loop
+define i32 @test7(i32 %A, i1 %b) {
+BB0:
+        br label %Loop
+
+Loop:           ; preds = %Loop, %BB0
+        ; PHI is dead.
+        %B = phi i32 [ %A, %BB0 ], [ %C, %Loop ]                ; <i32> [#uses=1]
+        %C = add i32 %B, 123            ; <i32> [#uses=1]
+        br i1 %b, label %Loop, label %Exit
 
-Loop:
-        %B = phi int [%A, %BB0], [%C, %Loop]    ; PHI is dead.
-	%C = add int %B, 123
-        br bool %b, label %Loop, label %Exit
-Exit:
-        ret int 0
+Exit:           ; preds = %Loop
+        ret i32 0
 }
 
+
diff --git a/test/Transforms/InstCombine/rem.ll b/test/Transforms/InstCombine/rem.ll
index 987d3c3db6..c0e0fa4dc3 100644
--- a/test/Transforms/InstCombine/rem.ll
+++ b/test/Transforms/InstCombine/rem.ll
@@ -1,79 +1,76 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep rem
-; END.
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep rem
 
-implementation
-
-int %test1(int %A) {
-	%B = rem int %A, 1    ; ISA constant 0
-	ret int %B
+define i32 @test1(i32 %A) {
+	%B = srem i32 %A, 1		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test2(int %A) {          ; 0 % X = 0, we don't need to preserve traps
-	%B = rem int 0, %A
-	ret int %B
+define i32 @test2(i32 %A) {
+	%B = srem i32 0, %A		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-uint %test3(uint %A) {
-	%B = rem uint %A, 8   ; & 7
-	ret uint %B
+define i32 @test3(i32 %A) {
+	%B = urem i32 %A, 8		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-bool %test3a(int %A) {
-	%B = rem int %A, -8   ; & 7
-	%C = setne int %B, 0
-	ret bool %C
+define i1 @test3a(i32 %A) {
+	%B = srem i32 %A, -8		; <i32> [#uses=1]
+	%C = icmp ne i32 %B, 0		; <i1> [#uses=1]
+	ret i1 %C
 }
 
-uint %test4(uint %X, bool %C) {
-	%V = select bool %C, uint 1, uint 8
-	%R = rem uint %X, %V
-	ret uint %R
+define i32 @test4(i32 %X, i1 %C) {
+	%V = select i1 %C, i32 1, i32 8		; <i32> [#uses=1]
+	%R = urem i32 %X, %V		; <i32> [#uses=1]
+	ret i32 %R
 }
 
-uint %test5(uint %X, ubyte %B) {
-        %Amt = shl uint 32, ubyte %B
-        %V = rem uint %X, %Amt
-        ret uint %V
+define i32 @test5(i32 %X, i8 %B) {
+	%shift.upgrd.1 = zext i8 %B to i32		; <i32> [#uses=1]
+	%Amt = shl i32 32, %shift.upgrd.1		; <i32> [#uses=1]
+	%V = urem i32 %X, %Amt		; <i32> [#uses=1]
+	ret i32 %V
 }
 
-int %test6(int %A) {
-	%B = rem int %A, 0   ;; undef
-	ret int %B
+define i32 @test6(i32 %A) {
+	%B = srem i32 %A, 0		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test7(int %A) {
-	%B = mul int %A, 26
-	%C = rem int %B, 13
-	ret int %C
+define i32 @test7(i32 %A) {
+	%B = mul i32 %A, 26		; <i32> [#uses=1]
+	%C = srem i32 %B, 13		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test8(int %A) {
-	%B = shl int %A, ubyte 4
-	%C = rem int %B, 8 
-	ret int %C
+define i32 @test8(i32 %A) {
+	%B = shl i32 %A, 4		; <i32> [#uses=1]
+	%C = srem i32 %B, 8		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test9(uint %A) {
-	%B = mul uint %A, 124
-	%C = rem uint %B, 62 
-	ret uint %C
+define i32 @test9(i32 %A) {
+	%B = mul i32 %A, 124		; <i32> [#uses=1]
+	%C = urem i32 %B, 62		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test10(ubyte %c) {
-        %tmp.1 = cast ubyte %c to int
-        %tmp.2 = mul int %tmp.1, 3
-        %tmp.3 = cast int %tmp.2 to ulong
-        %tmp.5 = rem ulong %tmp.3, 3
-        %tmp.6 = cast ulong %tmp.5 to int
-        ret int %tmp.6
+define i32 @test10(i8 %c) {
+	%tmp.1 = zext i8 %c to i32		; <i32> [#uses=1]
+	%tmp.2 = mul i32 %tmp.1, 3		; <i32> [#uses=1]
+	%tmp.3 = sext i32 %tmp.2 to i64		; <i64> [#uses=1]
+	%tmp.5 = urem i64 %tmp.3, 3		; <i64> [#uses=1]
+	%tmp.6 = trunc i64 %tmp.5 to i32		; <i32> [#uses=1]
+	ret i32 %tmp.6
 }
 
-int %test11(int %i) {
-        %tmp.1 = and int %i, -2
-        %tmp.3 = mul int %tmp.1, 3
-        %tmp.5 = rem int %tmp.3, 6
-        ret int %tmp.5
+define i32 @test11(i32 %i) {
+	%tmp.1 = and i32 %i, -2		; <i32> [#uses=1]
+	%tmp.3 = mul i32 %tmp.1, 3		; <i32> [#uses=1]
+	%tmp.5 = srem i32 %tmp.3, 6		; <i32> [#uses=1]
+	ret i32 %tmp.5
 }
-
diff --git a/test/Transforms/InstCombine/select.ll b/test/Transforms/InstCombine/select.ll
index aac7603e08..15083f2fac 100644
--- a/test/Transforms/InstCombine/select.ll
+++ b/test/Transforms/InstCombine/select.ll
@@ -1,190 +1,204 @@
 ; This test makes sure that these instructions are properly eliminated.
 ; PR1822
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep select
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep select
 
-implementation
-
-int %test1(int %A, int %B) {
-	%C = select bool false, int %A, int %B
-	ret int %C
+define i32 @test1(i32 %A, i32 %B) {
+        %C = select i1 false, i32 %A, i32 %B            ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-int %test2(int %A, int %B) {
-	%C = select bool true, int %A, int %B
-	ret int %C
+define i32 @test2(i32 %A, i32 %B) {
+        %C = select i1 true, i32 %A, i32 %B             ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-int %test3(bool %C, int %I) {
-	%V = select bool %C, int %I, int %I         ; V = I
-	ret int %V
+
+define i32 @test3(i1 %C, i32 %I) {
+        ; V = I
+        %V = select i1 %C, i32 %I, i32 %I               ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-bool %test4(bool %C) {
-	%V = select bool %C, bool true, bool false  ; V = C
-	ret bool %V
+define i1 @test4(i1 %C) {
+        ; V = C
+        %V = select i1 %C, i1 true, i1 false            ; <i1> [#uses=1]
+        ret i1 %V
 }
 
-bool %test5(bool %C) {
-	%V = select bool %C, bool false, bool true  ; V = !C
-	ret bool %V
+define i1 @test5(i1 %C) {
+        ; V = !C
+        %V = select i1 %C, i1 false, i1 true            ; <i1> [#uses=1]
+        ret i1 %V
 }
 
-int %test6(bool %C) {
-	%V = select bool %C, int 1, int 0         ; V = cast C to int
-	ret int %V
+define i32 @test6(i1 %C) { 
+        ; V = cast C to int
+        %V = select i1 %C, i32 1, i32 0         ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-bool %test7(bool %C, bool %X) {
-        %R = select bool %C, bool true, bool %X    ; R = or C, X
-        ret bool %R
+define i1 @test7(i1 %C, i1 %X) {
+        ; R = or C, X       
+        %R = select i1 %C, i1 true, i1 %X               ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-bool %test8(bool %C, bool %X) {
-        %R = select bool %C, bool %X, bool false   ; R = and C, X
-        ret bool %R
+define i1 @test8(i1 %C, i1 %X) {
+        ; R = and C, X
+        %R = select i1 %C, i1 %X, i1 false              ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-bool %test9(bool %C, bool %X) {
-        %R = select bool %C, bool false, bool %X    ; R = and !C, X
-        ret bool %R
+define i1 @test9(i1 %C, i1 %X) {
+        ; R = and !C, X
+        %R = select i1 %C, i1 false, i1 %X              ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-bool %test10(bool %C, bool %X) {
-        %R = select bool %C, bool %X, bool true   ; R = or !C, X
-        ret bool %R
+define i1 @test10(i1 %C, i1 %X) {
+        ; R = or !C, X
+        %R = select i1 %C, i1 %X, i1 true               ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-int %test11(int %a) {
-        %C = seteq int %a, 0
-        %R = select bool %C, int 0, int 1
-        ret int %R
+define i32 @test11(i32 %a) {
+        %C = icmp eq i32 %a, 0          ; <i1> [#uses=1]
+        %R = select i1 %C, i32 0, i32 1         ; <i32> [#uses=1]
+        ret i32 %R
 }
 
-int %test12(bool %cond, int %a) {
-	%b = or int %a, 1
-	%c = select bool %cond, int %b, int %a
-	ret int %c
+define i32 @test12(i1 %cond, i32 %a) {
+        %b = or i32 %a, 1               ; <i32> [#uses=1]
+        %c = select i1 %cond, i32 %b, i32 %a            ; <i32> [#uses=1]
+        ret i32 %c
 }
 
-int %test12a(bool %cond, int %a) {
-	%b = shr int %a, ubyte 1
-	%c = select bool %cond, int %b, int %a
-	ret int %c
+define i32 @test12a(i1 %cond, i32 %a) {
+        %b = ashr i32 %a, 1             ; <i32> [#uses=1]
+        %c = select i1 %cond, i32 %b, i32 %a            ; <i32> [#uses=1]
+        ret i32 %c
 }
 
-int %test12b(bool %cond, int %a) {
-	%b = shr int %a, ubyte 1
-	%c = select bool %cond, int %a, int %b
-	ret int %c
+define i32 @test12b(i1 %cond, i32 %a) {
+        %b = ashr i32 %a, 1             ; <i32> [#uses=1]
+        %c = select i1 %cond, i32 %a, i32 %b            ; <i32> [#uses=1]
+        ret i32 %c
 }
 
-int %test13(int %a, int %b) {
-	%C = seteq int %a, %b
-	%V = select bool %C, int %a, int %b
-	ret int %V
+define i32 @test13(i32 %a, i32 %b) {
+        %C = icmp eq i32 %a, %b         ; <i1> [#uses=1]
+        %V = select i1 %C, i32 %a, i32 %b               ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-int %test13a(int %a, int %b) {
-	%C = setne int %a, %b
-	%V = select bool %C, int %a, int %b
-	ret int %V
+define i32 @test13a(i32 %a, i32 %b) {
+        %C = icmp ne i32 %a, %b         ; <i1> [#uses=1]
+        %V = select i1 %C, i32 %a, i32 %b               ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-int %test13b(int %a, int %b) {
-	%C = seteq int %a, %b
-	%V = select bool %C, int %b, int %a
-	ret int %V
+define i32 @test13b(i32 %a, i32 %b) {
+        %C = icmp eq i32 %a, %b         ; <i1> [#uses=1]
+        %V = select i1 %C, i32 %b, i32 %a               ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-bool %test14a(bool %C, int %X) {
-	%V = select bool %C, int %X, int 0
-	%R = setlt int %V, 1                  ; (X < 1) | !C
-	ret bool %R
+define i1 @test14a(i1 %C, i32 %X) {
+        %V = select i1 %C, i32 %X, i32 0                ; <i32> [#uses=1]
+        ; (X < 1) | !C
+        %R = icmp slt i32 %V, 1         ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-bool %test14b(bool %C, int %X) {
-	%V = select bool %C, int 0, int %X
-	%R = setlt int %V, 1                  ; (X < 1) | C
-	ret bool %R
+define i1 @test14b(i1 %C, i32 %X) {
+        %V = select i1 %C, i32 0, i32 %X                ; <i32> [#uses=1]
+        ; (X < 1) | C
+        %R = icmp slt i32 %V, 1         ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-int %test15a(int %X) {       ;; Code sequence for (X & 16) ? 16 : 0
-        %t1 = and int %X, 16
-        %t2 = seteq int %t1, 0
-        %t3 = select bool %t2, int 0, int 16 ;; X & 16
-        ret int %t3
+;; Code sequence for (X & 16) ? 16 : 0
+define i32 @test15a(i32 %X) {
+        %t1 = and i32 %X, 16            ; <i32> [#uses=1]
+        %t2 = icmp eq i32 %t1, 0                ; <i1> [#uses=1]
+        %t3 = select i1 %t2, i32 0, i32 16              ; <i32> [#uses=1]
+        ret i32 %t3
 }
 
-int %test15b(int %X) {       ;; Code sequence for (X & 32) ? 0 : 24
-        %t1 = and int %X, 32
-        %t2 = seteq int %t1, 0
-        %t3 = select bool %t2, int 32, int 0 ;; ~X & 32
-        ret int %t3
+;; Code sequence for (X & 32) ? 0 : 24
+define i32 @test15b(i32 %X) {
+        %t1 = and i32 %X, 32            ; <i32> [#uses=1]
+        %t2 = icmp eq i32 %t1, 0                ; <i1> [#uses=1]
+        %t3 = select i1 %t2, i32 32, i32 0              ; <i32> [#uses=1]
+        ret i32 %t3
 }
 
-int %test15c(int %X) {       ;; Alternate code sequence for (X & 16) ? 16 : 0
-        %t1 = and int %X, 16
-        %t2 = seteq int %t1, 16
-        %t3 = select bool %t2, int 16, int 0 ;; X & 16
-        ret int %t3
+;; Alternate code sequence for (X & 16) ? 16 : 0
+define i32 @test15c(i32 %X) {
+        %t1 = and i32 %X, 16            ; <i32> [#uses=1]
+        %t2 = icmp eq i32 %t1, 16               ; <i1> [#uses=1]
+        %t3 = select i1 %t2, i32 16, i32 0              ; <i32> [#uses=1]
+        ret i32 %t3
 }
 
-int %test15d(int %X) {       ;; Alternate code sequence for (X & 16) ? 16 : 0
-        %t1 = and int %X, 16
-        %t2 = setne int %t1, 0
-        %t3 = select bool %t2, int 16, int 0 ;; X & 16
-        ret int %t3
+;; Alternate code sequence for (X & 16) ? 16 : 0
+define i32 @test15d(i32 %X) {
+        %t1 = and i32 %X, 16            ; <i32> [#uses=1]
+        %t2 = icmp ne i32 %t1, 0                ; <i1> [#uses=1]
+        %t3 = select i1 %t2, i32 16, i32 0              ; <i32> [#uses=1]
+        ret i32 %t3
 }
 
-int %test16(bool %C, int* %P) {
-	%P2 = select bool %C, int* %P, int* null
-	%V = load int* %P2
-	ret int %V
+define i32 @test16(i1 %C, i32* %P) {
+        %P2 = select i1 %C, i32* %P, i32* null          ; <i32*> [#uses=1]
+        %V = load i32* %P2              ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-bool %test17(int* %X, bool %C) {
-	%R = select bool %C, int* %X, int* null
-	%RV = seteq int* %R, null
-	ret bool %RV
+define i1 @test17(i32* %X, i1 %C) {
+        %R = select i1 %C, i32* %X, i32* null           ; <i32*> [#uses=1]
+        %RV = icmp eq i32* %R, null             ; <i1> [#uses=1]
+        ret i1 %RV
 }
 
-int %test18(int %X, int %Y, bool %C) {
-	%R = select bool %C, int %X, int 0
-	%V = div int %Y, %R   ; div Y,X
-	ret int %V
+define i32 @test18(i32 %X, i32 %Y, i1 %C) {
+        %R = select i1 %C, i32 %X, i32 0                ; <i32> [#uses=1]
+        %V = sdiv i32 %Y, %R            ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-int %test19(uint %x) {
-        %tmp = setgt uint %x, 2147483647
-        %retval = select bool %tmp, int -1, int 0
-        ret int %retval
+define i32 @test19(i32 %x) {
+        %tmp = icmp ugt i32 %x, 2147483647              ; <i1> [#uses=1]
+        %retval = select i1 %tmp, i32 -1, i32 0         ; <i32> [#uses=1]
+        ret i32 %retval
 }
 
-int %test20(int %x) {
-        %tmp = setlt int %x, 0
-        %retval = select bool %tmp, int -1, int 0
-        ret int %retval
+define i32 @test20(i32 %x) {
+        %tmp = icmp slt i32 %x, 0               ; <i1> [#uses=1]
+        %retval = select i1 %tmp, i32 -1, i32 0         ; <i32> [#uses=1]
+        ret i32 %retval
 }
 
-long %test21(int %x) {
-        %tmp = setlt int %x, 0
-        %retval = select bool %tmp, long -1, long 0
-        ret long %retval
+define i64 @test21(i32 %x) {
+        %tmp = icmp slt i32 %x, 0               ; <i1> [#uses=1]
+        %retval = select i1 %tmp, i64 -1, i64 0         ; <i64> [#uses=1]
+        ret i64 %retval
 }
 
-short %test22(int %x) {
-        %tmp = setlt int %x, 0
-        %retval = select bool %tmp, short -1, short 0
-        ret short %retval
+define i16 @test22(i32 %x) {
+        %tmp = icmp slt i32 %x, 0               ; <i1> [#uses=1]
+        %retval = select i1 %tmp, i16 -1, i16 0         ; <i16> [#uses=1]
+        ret i16 %retval
 }
 
-bool %test23(bool %a, bool %b) {
-	%c = select bool %a, bool %b, bool %a
-	ret bool %c
+define i1 @test23(i1 %a, i1 %b) {
+        %c = select i1 %a, i1 %b, i1 %a         ; <i1> [#uses=1]
+        ret i1 %c
 }
 
-bool %test24(bool %a, bool %b) {
-	%c = select bool %a, bool %a, bool %b
-	ret bool %c
+define i1 @test24(i1 %a, i1 %b) {
+        %c = select i1 %a, i1 %a, i1 %b         ; <i1> [#uses=1]
+        ret i1 %c
 }
+
diff --git a/test/Transforms/InstCombine/set.ll b/test/Transforms/InstCombine/set.ll
index 51cffbeba9..76e606beaf 100644
--- a/test/Transforms/InstCombine/set.ll
+++ b/test/Transforms/InstCombine/set.ll
@@ -1,152 +1,170 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep icmp
-; END.
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep icmp
+	
+@X = external global i32                ; <i32*> [#uses=2]
 
-%X = uninitialized global int
-
-bool %test1(int %A) {
-	%B = seteq int %A, %A
-	%C = seteq int* %X, null   ; Never true
-	%D = and bool %B, %C
-	ret bool %D
+define i1 @test1(i32 %A) {
+        %B = icmp eq i32 %A, %A         ; <i1> [#uses=1]
+        ; Never true
+        %C = icmp eq i32* @X, null              ; <i1> [#uses=1]
+        %D = and i1 %B, %C              ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-bool %test2(int %A) {
-	%B = setne int %A, %A
-	%C = setne int* %X, null   ; Never false
-	%D = or bool %B, %C
-	ret bool %D
+define i1 @test2(i32 %A) {
+        %B = icmp ne i32 %A, %A         ; <i1> [#uses=1]
+        ; Never false
+        %C = icmp ne i32* @X, null              ; <i1> [#uses=1]
+        %D = or i1 %B, %C               ; <i1> [#uses=1]
+        ret i1 %D
 }
 
-bool %test3(int %A) {
-	%B = setlt int %A, %A
-	ret bool %B
+define i1 @test3(i32 %A) {
+        %B = icmp slt i32 %A, %A                ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test4(int %A) {
-	%B = setgt int %A, %A
-	ret bool %B
+
+define i1 @test4(i32 %A) {
+        %B = icmp sgt i32 %A, %A                ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test5(int %A) {
-	%B = setle int %A, %A
-	ret bool %B
+define i1 @test5(i32 %A) {
+        %B = icmp sle i32 %A, %A                ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test6(int %A) {
-	%B = setge int %A, %A
-	ret bool %B
+define i1 @test6(i32 %A) {
+        %B = icmp sge i32 %A, %A                ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test7(uint %A) {
-	%B = setge uint %A, 0  ; true
-	ret bool %B
+define i1 @test7(i32 %A) {
+        ; true
+        %B = icmp uge i32 %A, 0         ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test8(uint %A) {
-	%B = setlt uint %A, 0  ; false
-	ret bool %B
+define i1 @test8(i32 %A) {
+        ; false
+        %B = icmp ult i32 %A, 0         ; <i1> [#uses=1]
+        ret i1 %B
 }
 
 ;; test operations on boolean values these should all be eliminated$a
-bool %test9(bool %A) {
-	%B = setlt bool %A, false ; false
-	ret bool %B
+define i1 @test9(i1 %A) {
+        ; false
+        %B = icmp ult i1 %A, false              ; <i1> [#uses=1]
+        ret i1 %B
 }
-bool %test10(bool %A) {
-	%B = setgt bool %A, true  ; false
-	ret bool %B
+
+define i1 @test10(i1 %A) {
+        ; false
+        %B = icmp ugt i1 %A, true               ; <i1> [#uses=1]
+        ret i1 %B
 }
-bool %test11(bool %A) {
-	%B = setle bool %A, true ; true
-	ret bool %B
+
+define i1 @test11(i1 %A) {
+        ; true
+        %B = icmp ule i1 %A, true               ; <i1> [#uses=1]
+        ret i1 %B
 }
-bool %test12(bool %A) {
-	%B = setge bool %A, false  ; true
-	ret bool %B
+
+define i1 @test12(i1 %A) {
+        ; true
+        %B = icmp uge i1 %A, false              ; <i1> [#uses=1]
+        ret i1 %B
 }
-bool %test13(bool %A, bool %B) {
-	%C = setge bool %A, %B       ; A | ~B
-	ret bool %C
+
+define i1 @test13(i1 %A, i1 %B) {
+        ; A | ~B
+        %C = icmp uge i1 %A, %B         ; <i1> [#uses=1]
+        ret i1 %C
 }
-bool %test14(bool %A, bool %B) {
-	%C = seteq bool %A, %B  ; ~(A ^ B)
-	ret bool %C
+
+define i1 @test14(i1 %A, i1 %B) {
+        ; ~(A ^ B)
+        %C = icmp eq i1 %A, %B          ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test16(uint %A) {
-	%B = and uint %A, 5
-	%C = seteq uint %B, 8    ; Is never true
-	ret bool %C
+define i1 @test16(i32 %A) {
+        %B = and i32 %A, 5              ; <i32> [#uses=1]
+        ; Is never true
+        %C = icmp eq i32 %B, 8          ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test17(ubyte %A) {
-	%B = or ubyte %A, 1
-	%C = seteq ubyte %B, 2   ; Always false
-	ret bool %C
+define i1 @test17(i8 %A) {
+        %B = or i8 %A, 1                ; <i8> [#uses=1]
+        ; Always false
+        %C = icmp eq i8 %B, 2           ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test18(bool %C, int %a) {
+define i1 @test18(i1 %C, i32 %a) {
 entry:
-        br bool %C, label %endif, label %else
+        br i1 %C, label %endif, label %else
 
-else:
+else:           ; preds = %entry
         br label %endif
 
-endif:
-        %b.0 = phi int [ 0, %entry ], [ 1, %else ]
-        %tmp.4 = setlt int %b.0, 123
-        ret bool %tmp.4
+endif:          ; preds = %else, %entry
+        %b.0 = phi i32 [ 0, %entry ], [ 1, %else ]              ; <i32> [#uses=1]
+        %tmp.4 = icmp slt i32 %b.0, 123         ; <i1> [#uses=1]
+        ret i1 %tmp.4
 }
 
-bool %test19(bool %A, bool %B) {
-	%a = cast bool %A to int
-	%b = cast bool %B to int
-	%C = seteq int %a, %b
-	ret bool %C
+define i1 @test19(i1 %A, i1 %B) {
+        %a = zext i1 %A to i32          ; <i32> [#uses=1]
+        %b = zext i1 %B to i32          ; <i32> [#uses=1]
+        %C = icmp eq i32 %a, %b         ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-uint %test20(uint %A) {
-        %B = and uint %A, 1
-        %C = setne uint %B, 0
-        %D = cast bool %C to uint
-        ret uint %D
+define i32 @test20(i32 %A) {
+        %B = and i32 %A, 1              ; <i32> [#uses=1]
+        %C = icmp ne i32 %B, 0          ; <i1> [#uses=1]
+        %D = zext i1 %C to i32          ; <i32> [#uses=1]
+        ret i32 %D
 }
 
-int %test21(int %a) {
-        %tmp.6 = and int %a, 4
-        %not.tmp.7 = setne int %tmp.6, 0
-        %retval = cast bool %not.tmp.7 to int
-        ret int %retval
+define i32 @test21(i32 %a) {
+        %tmp.6 = and i32 %a, 4          ; <i32> [#uses=1]
+        %not.tmp.7 = icmp ne i32 %tmp.6, 0              ; <i1> [#uses=1]
+        %retval = zext i1 %not.tmp.7 to i32             ; <i32> [#uses=1]
+        ret i32 %retval
 }
 
-bool %test22(uint %A, int %X) {
-        %B = and uint %A, 100663295
-        %C = setlt uint %B, 268435456
-	%Y = and int %X, 7
-	%Z = setgt int %Y, -1
-	%R = or bool %C, %Z
-	ret bool %R
+define i1 @test22(i32 %A, i32 %X) {
+        %B = and i32 %A, 100663295              ; <i32> [#uses=1]
+        %C = icmp ult i32 %B, 268435456         ; <i1> [#uses=1]
+        %Y = and i32 %X, 7              ; <i32> [#uses=1]
+        %Z = icmp sgt i32 %Y, -1                ; <i1> [#uses=1]
+        %R = or i1 %C, %Z               ; <i1> [#uses=1]
+        ret i1 %R
 }
 
-int %test23(int %a) {
-        %tmp.1 = and int %a, 1
-        %tmp.2 = seteq int %tmp.1, 0
-        %tmp.3 = cast bool %tmp.2 to int  ;; xor tmp1, 1
-        ret int %tmp.3
+define i32 @test23(i32 %a) {
+        %tmp.1 = and i32 %a, 1          ; <i32> [#uses=1]
+        %tmp.2 = icmp eq i32 %tmp.1, 0          ; <i1> [#uses=1]
+        %tmp.3 = zext i1 %tmp.2 to i32          ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
-int %test24(uint %a) {
-        %tmp1 = and uint %a, 4
-	%tmp.1 = shr uint %tmp1, ubyte 2
-        %tmp.2 = seteq uint %tmp.1, 0
-        %tmp.3 = cast bool %tmp.2 to int  ;; xor tmp1, 1
-        ret int %tmp.3
+define i32 @test24(i32 %a) {
+        %tmp1 = and i32 %a, 4           ; <i32> [#uses=1]
+        %tmp.1 = lshr i32 %tmp1, 2              ; <i32> [#uses=1]
+        %tmp.2 = icmp eq i32 %tmp.1, 0          ; <i1> [#uses=1]
+        %tmp.3 = zext i1 %tmp.2 to i32          ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
-bool %test25(uint %A) {
-	%B = and uint %A, 2
-	%C = setgt uint %B, 2
-	ret bool %C
+define i1 @test25(i32 %A) {
+        %B = and i32 %A, 2              ; <i32> [#uses=1]
+        %C = icmp ugt i32 %B, 2         ; <i1> [#uses=1]
+        ret i1 %C
 }
+
diff --git a/test/Transforms/InstCombine/setcc-cast-cast.ll b/test/Transforms/InstCombine/setcc-cast-cast.ll
index 903f0b4917..79f40aced5 100644
--- a/test/Transforms/InstCombine/setcc-cast-cast.ll
+++ b/test/Transforms/InstCombine/setcc-cast-cast.ll
@@ -1,45 +1,45 @@
 ; This test case was reduced from MultiSource/Applications/hbd. It makes sure
 ; that folding doesn't happen in case a zext is applied where a sext should have
 ; been when a setcc is used with two casts.
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep {br bool false}
-; END.
 
-int %bug(ubyte %inbuff) {
+define i32 @bug(i8 %inbuff) {
 entry:
-	%tmp = bitcast ubyte %inbuff to sbyte   ; <sbyte> [#uses=1]
-	%tmp = sext sbyte %tmp to int		; <int> [#uses=3]
-	%tmp = seteq int %tmp, 1		; <bool> [#uses=1]
-	br bool %tmp, label %cond_true, label %cond_next
+        %tmp = bitcast i8 %inbuff to i8         ; <i8> [#uses=1]
+        %tmp.upgrd.1 = sext i8 %tmp to i32              ; <i32> [#uses=3]
+        %tmp.upgrd.2 = icmp eq i32 %tmp.upgrd.1, 1              ; <i1> [#uses=1]
+        br i1 %tmp.upgrd.2, label %cond_true, label %cond_next
 
-cond_true:		; preds = %entry
-	br label %bb
+cond_true:              ; preds = %entry
+        br label %bb
 
-cond_next:		; preds = %entry
-	%tmp3 = seteq int %tmp, -1		; <bool> [#uses=1]
-	br bool %tmp3, label %cond_true4, label %cond_next5
+cond_next:              ; preds = %entry
+        %tmp3 = icmp eq i32 %tmp.upgrd.1, -1            ; <i1> [#uses=1]
+        br i1 %tmp3, label %cond_true4, label %cond_next5
 
-cond_true4:		; preds = %cond_next
-	br label %bb
+cond_true4:             ; preds = %cond_next
+        br label %bb
 
-cond_next5:		; preds = %cond_next
-	%tmp7 = setgt int %tmp, 1		; <bool> [#uses=1]
-	br bool %tmp7, label %cond_true8, label %cond_false
+cond_next5:             ; preds = %cond_next
+        %tmp7 = icmp sgt i32 %tmp.upgrd.1, 1            ; <i1> [#uses=1]
+        br i1 %tmp7, label %cond_true8, label %cond_false
 
-cond_true8:		; preds = %cond_next5
-	br label %cond_next9
+cond_true8:             ; preds = %cond_next5
+        br label %cond_next9
 
-cond_false:		; preds = %cond_next5
-	br label %cond_next9
+cond_false:             ; preds = %cond_next5
+        br label %cond_next9
 
-cond_next9:		; preds = %cond_false, %cond_true8
-	%iftmp.1.0 = phi int [ 42, %cond_true8 ], [ 23, %cond_false ]		; <int> [#uses=1]
-	br label %return
+cond_next9:             ; preds = %cond_false, %cond_true8
+        %iftmp.1.0 = phi i32 [ 42, %cond_true8 ], [ 23, %cond_false ]           ; <i32> [#uses=1]
+        br label %return
 
-bb:		; preds = %cond_true4, %cond_true
-	br label %return
+bb:             ; preds = %cond_true4, %cond_true
+        br label %return
 
-return:		; preds = %bb, %cond_next9
-	%retval.0 = phi int [ 17, %bb ], [ %iftmp.1.0, %cond_next9 ]		; <int> [#uses=1]
-	ret int %retval.0
+return:         ; preds = %bb, %cond_next9
+        %retval.0 = phi i32 [ 17, %bb ], [ %iftmp.1.0, %cond_next9 ]            ; <i32> [#uses=1]
+        ret i32 %retval.0
 }
+
diff --git a/test/Transforms/InstCombine/setcc-strength-reduce.ll b/test/Transforms/InstCombine/setcc-strength-reduce.ll
index b5ea83707d..4c420ab421 100644
--- a/test/Transforms/InstCombine/setcc-strength-reduce.ll
+++ b/test/Transforms/InstCombine/setcc-strength-reduce.ll
@@ -2,31 +2,36 @@
 ; working.  Basically this boils down to converting setlt,gt,le,ge instructions
 ; into equivalent setne,eq instructions.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep -v {icmp eq} | grep -v {icmp ne} | not grep icmp
-; END.
 
-bool %test1(uint %A) {
-	%B = setge uint %A, 1   ; setne %A, 0
-	ret bool %B
+
+define i1 @test1(i32 %A) {
+        ; setne %A, 0
+        %B = icmp uge i32 %A, 1         ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test2(uint %A) {
-	%B = setgt uint %A, 0   ; setne %A, 0
-	ret bool %B
+define i1 @test2(i32 %A) {
+       ; setne %A, 0
+        %B = icmp ugt i32 %A, 0         ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test3(sbyte %A) {
-	%B = setge sbyte %A, -127   ; setne %A, -128
-	ret bool %B
+define i1 @test3(i8 %A) {
+        ; setne %A, -128
+        %B = icmp sge i8 %A, -127               ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test4(sbyte %A) {
-	%B = setle sbyte %A, 126  ; setne %A, 127
-	ret bool %B
+define i1 @test4(i8 %A) {
+        ; setne %A, 127 
+        %B = icmp sle i8 %A, 126                ; <i1> [#uses=1]
+        ret i1 %B
 }
 
-bool %test5(sbyte %A) {
-	%B = setlt sbyte %A, 127 ; setne %A, 127
-	ret bool %B
+define i1 @test5(i8 %A) {
+        ; setne %A, 127
+        %B = icmp slt i8 %A, 127                ; <i1> [#uses=1]
+        ret i1 %B
 }
diff --git a/test/Transforms/InstCombine/shift-sra.ll b/test/Transforms/InstCombine/shift-sra.ll
index 1339eddc87..6058bd6dc7 100644
--- a/test/Transforms/InstCombine/shift-sra.ll
+++ b/test/Transforms/InstCombine/shift-sra.ll
@@ -1,17 +1,19 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    grep {lshr i32} | count 2
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep ashr
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep ashr
 
-int %test1(int %X, ubyte %A) {
-	%Y = shr int %X, ubyte %A  ; can be logical shift.
-	%Z = and int %Y, 1
-	ret int %Z
-}
 
-int %test2(ubyte %tmp) {
-        %tmp3 = cast ubyte %tmp to int
-        %tmp4 = add int %tmp3, 7
-        %tmp5 = ashr int %tmp4, ubyte 3   ; lshr
-        ret int %tmp5
+define i32 @test1(i32 %X, i8 %A) {
+        %shift.upgrd.1 = zext i8 %A to i32              ; <i32> [#uses=1]
+        ; can be logical shift.
+        %Y = ashr i32 %X, %shift.upgrd.1                ; <i32> [#uses=1]
+        %Z = and i32 %Y, 1              ; <i32> [#uses=1]
+        ret i32 %Z
 }
 
+define i32 @test2(i8 %tmp) {
+        %tmp3 = zext i8 %tmp to i32             ; <i32> [#uses=1]
+        %tmp4 = add i32 %tmp3, 7                ; <i32> [#uses=1]
+        %tmp5 = ashr i32 %tmp4, 3               ; <i32> [#uses=1]
+        ret i32 %tmp5
+}
diff --git a/test/Transforms/InstCombine/shift.ll b/test/Transforms/InstCombine/shift.ll
index 5ce807063d..feb7c64912 100644
--- a/test/Transforms/InstCombine/shift.ll
+++ b/test/Transforms/InstCombine/shift.ll
@@ -1,189 +1,208 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep sh
-; END.
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep sh
 
-implementation
-
-int %test1(int %A) {
-	%B = shl int %A, ubyte 0
-	ret int %B
+define i32 @test1(i32 %A) {
+        %B = shl i32 %A, 0              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test2(ubyte %A) {
-	%B = shl int 0, ubyte %A
-	ret int %B
+define i32 @test2(i8 %A) {
+        %shift.upgrd.1 = zext i8 %A to i32              ; <i32> [#uses=1]
+        %B = shl i32 0, %shift.upgrd.1          ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test3(int %A) {
-	%B = shr int %A, ubyte 0
-	ret int %B
+define i32 @test3(i32 %A) {
+        %B = ashr i32 %A, 0             ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test4(ubyte %A) {
-	%B = shr int 0, ubyte %A
-	ret int %B
+define i32 @test4(i8 %A) {
+        %shift.upgrd.2 = zext i8 %A to i32              ; <i32> [#uses=1]
+        %B = ashr i32 0, %shift.upgrd.2         ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-uint %test5(uint %A) {
-	%B = shr uint %A, ubyte 32  ;; shift all bits out
-	ret uint %B
+
+define i32 @test5(i32 %A) {
+        %B = lshr i32 %A, 32  ;; shift all bits out 
+        ret i32 %B
 }
 
-uint %test5a(uint %A) {
-	%B = shl uint %A, ubyte 32  ;; shift all bits out
-	ret uint %B
+define i32 @test5a(i32 %A) {
+        %B = shl i32 %A, 32     ;; shift all bits out 
+        ret i32 %B
 }
 
-uint %test6(uint %A) {
-	%B = shl uint %A, ubyte 1   ;; convert to an mul instruction
-	%C = mul uint %B, 3
-	ret uint %C
+define i32 @test6(i32 %A) {
+        %B = shl i32 %A, 1      ;; convert to an mul instruction 
+        %C = mul i32 %B, 3             
+        ret i32 %C
 }
 
-int %test7(ubyte %A) {
-	%B = shr int -1, ubyte %A   ;; Always equal to -1
-	ret int %B
+define i32 @test7(i8 %A) {
+        %shift.upgrd.3 = zext i8 %A to i32 
+        %B = ashr i32 -1, %shift.upgrd.3  ;; Always equal to -1
+        ret i32 %B
 }
 
-ubyte %test8(ubyte %A) {              ;; (A << 5) << 3 === A << 8 == 0
-	%B = shl ubyte %A, ubyte 5
-	%C = shl ubyte %B, ubyte 3
-	ret ubyte %C
+;; (A << 5) << 3 === A << 8 == 0
+define i8 @test8(i8 %A) {
+        %B = shl i8 %A, 5               ; <i8> [#uses=1]
+        %C = shl i8 %B, 3               ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-ubyte %test9(ubyte %A) {              ;; (A << 7) >> 7 === A & 1
-	%B = shl ubyte %A, ubyte 7
-	%C = shr ubyte %B, ubyte 7
-	ret ubyte %C
+;; (A << 7) >> 7 === A & 1
+define i8 @test9(i8 %A) {
+        %B = shl i8 %A, 7               ; <i8> [#uses=1]
+        %C = lshr i8 %B, 7              ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-ubyte %test10(ubyte %A) {              ;; (A >> 7) << 7 === A & 128
-	%B = shr ubyte %A, ubyte 7
-	%C = shl ubyte %B, ubyte 7
-	ret ubyte %C
+;; (A >> 7) << 7 === A & 128
+define i8 @test10(i8 %A) {
+        %B = lshr i8 %A, 7              ; <i8> [#uses=1]
+        %C = shl i8 %B, 7               ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-ubyte %test11(ubyte %A) {              ;; (A >> 3) << 4 === (A & 0x1F) << 1
-	%a = mul ubyte %A, 3
-	%B = shr ubyte %a, ubyte 3
-	%C = shl ubyte %B, ubyte 4
-	ret ubyte %C
+;; (A >> 3) << 4 === (A & 0x1F) << 1
+define i8 @test11(i8 %A) {
+        %a = mul i8 %A, 3               ; <i8> [#uses=1]
+        %B = lshr i8 %a, 3              ; <i8> [#uses=1]
+        %C = shl i8 %B, 4               ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-int %test12(int %A) {
-        %B = shr int %A, ubyte 8    ;; (A >> 8) << 8 === A & -256
-        %C = shl int %B, ubyte 8
-        ret int %C
+;; (A >> 8) << 8 === A & -256
+define i32 @test12(i32 %A) {
+        %B = ashr i32 %A, 8             ; <i32> [#uses=1]
+        %C = shl i32 %B, 8              ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-sbyte %test13(sbyte %A) {           ;; (A >> 3) << 4 === (A & -8) * 2
-	%a = mul sbyte %A, 3
-	%B = shr sbyte %a, ubyte 3
-	%C = shl sbyte %B, ubyte 4
-	ret sbyte %C
+;; (A >> 3) << 4 === (A & -8) * 2
+define i8 @test13(i8 %A) {
+        %a = mul i8 %A, 3               ; <i8> [#uses=1]
+        %B = ashr i8 %a, 3              ; <i8> [#uses=1]
+        %C = shl i8 %B, 4               ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-uint %test14(uint %A) {
-	%B = shr uint %A, ubyte 4
-	%C = or uint %B, 1234
-	%D = shl uint %C, ubyte 4   ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4)
-	ret uint %D
+;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4)
+define i32 @test14(i32 %A) {
+        %B = lshr i32 %A, 4             ; <i32> [#uses=1]
+        %C = or i32 %B, 1234            ; <i32> [#uses=1]
+        %D = shl i32 %C, 4              ; <i32> [#uses=1]
+        ret i32 %D
 }
-uint %test14a(uint %A) {
-	%B = shl uint %A, ubyte 4
-	%C = and uint %B, 1234
-	%D = shr uint %C, ubyte 4   ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4)
-	ret uint %D
+
+;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4)
+define i32 @test14a(i32 %A) {
+        %B = shl i32 %A, 4              ; <i32> [#uses=1]
+        %C = and i32 %B, 1234           ; <i32> [#uses=1]
+        %D = lshr i32 %C, 4             ; <i32> [#uses=1]
+        ret i32 %D
 }
 
-int %test15(bool %C) {
-        %A = select bool %C, int 3, int 1
-        %V = shl int %A, ubyte 2
-        ret int %V
+define i32 @test15(i1 %C) {
+        %A = select i1 %C, i32 3, i32 1         ; <i32> [#uses=1]
+        %V = shl i32 %A, 2              ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-int %test15a(bool %C) {
-        %A = select bool %C, ubyte 3, ubyte 1
-        %V = shl int 64, ubyte %A
-        ret int %V
+define i32 @test15a(i1 %C) {
+        %A = select i1 %C, i8 3, i8 1           ; <i8> [#uses=1]
+        %shift.upgrd.4 = zext i8 %A to i32              ; <i32> [#uses=1]
+        %V = shl i32 64, %shift.upgrd.4         ; <i32> [#uses=1]
+        ret i32 %V
 }
 
-bool %test16(int %X) {
-        %tmp.3 = shr int %X, ubyte 4
-        %tmp.6 = and int %tmp.3, 1
-        %tmp.7 = setne int %tmp.6, 0  ;; X & 16 != 0
-        ret bool %tmp.7
+define i1 @test16(i32 %X) {
+        %tmp.3 = ashr i32 %X, 4         ; <i32> [#uses=1]
+        %tmp.6 = and i32 %tmp.3, 1              ; <i32> [#uses=1]
+        %tmp.7 = icmp ne i32 %tmp.6, 0          ; <i1> [#uses=1]
+        ret i1 %tmp.7
 }
 
-bool %test17(uint %A) {
-	%B = shr uint %A, ubyte 3
-	%C = seteq uint %B, 1234
-	ret bool %C
+define i1 @test17(i32 %A) {
+        %B = lshr i32 %A, 3             ; <i32> [#uses=1]
+        %C = icmp eq i32 %B, 1234               ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test18(ubyte %A) {
-	%B = shr ubyte %A, ubyte 7
-	%C = seteq ubyte %B, 123    ;; false
-	ret bool %C
+
+define i1 @test18(i8 %A) {
+        %B = lshr i8 %A, 7              ; <i8> [#uses=1]
+        ;; false
+        %C = icmp eq i8 %B, 123         ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test19(int %A) {
-	%B = shr int %A, ubyte 2
-	%C = seteq int %B, 0        ;; (X & -4) == 0
-	ret bool %C
+define i1 @test19(i32 %A) {
+        %B = ashr i32 %A, 2             ; <i32> [#uses=1]
+        ;; (X & -4) == 0
+        %C = icmp eq i32 %B, 0          ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test19a(int %A) {
-	%B = shr int %A, ubyte 2
-	%C = seteq int %B, -1        ;; (X & -4) == -4
-	ret bool %C
+
+define i1 @test19a(i32 %A) {
+        %B = ashr i32 %A, 2             ; <i32> [#uses=1]
+        ;; (X & -4) == -4
+        %C = icmp eq i32 %B, -1         ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test20(sbyte %A) {
-	%B = shr sbyte %A, ubyte 7
-	%C = seteq sbyte %B, 123    ;; false
-	ret bool %C
+define i1 @test20(i8 %A) {
+        %B = ashr i8 %A, 7              ; <i8> [#uses=1]
+        ;; false
+        %C = icmp eq i8 %B, 123         ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test21(ubyte %A) {
-	%B = shl ubyte %A, ubyte 4
-	%C = seteq ubyte %B, 128
-	ret bool %C
+define i1 @test21(i8 %A) {
+        %B = shl i8 %A, 4               ; <i8> [#uses=1]
+        %C = icmp eq i8 %B, -128                ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test22(ubyte %A) {
-	%B = shl ubyte %A, ubyte 4
-	%C = seteq ubyte %B, 0
-	ret bool %C
+define i1 @test22(i8 %A) {
+        %B = shl i8 %A, 4               ; <i8> [#uses=1]
+        %C = icmp eq i8 %B, 0           ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-sbyte %test23(int %A) {
-	%B = shl int %A, ubyte 24  ;; casts not needed
-	%C = shr int %B, ubyte 24
-	%D = cast int %C to sbyte
-	ret sbyte %D
+define i8 @test23(i32 %A) {
+        ;; casts not needed
+        %B = shl i32 %A, 24             ; <i32> [#uses=1]
+        %C = ashr i32 %B, 24            ; <i32> [#uses=1]
+        %D = trunc i32 %C to i8         ; <i8> [#uses=1]
+        ret i8 %D
 }
 
-sbyte %test24(sbyte %X) {
-        %Y = and sbyte %X, -5 ; ~4
-        %Z = shl sbyte %Y, ubyte 5
-        %Q = shr sbyte %Z, ubyte 5
-        ret sbyte %Q
+define i8 @test24(i8 %X) {
+        %Y = and i8 %X, -5              ; <i8> [#uses=1]
+        %Z = shl i8 %Y, 5               ; <i8> [#uses=1]
+        %Q = ashr i8 %Z, 5              ; <i8> [#uses=1]
+        ret i8 %Q
 }
 
-uint %test25(uint %tmp.2, uint %AA) {
-	%x = shr uint %AA, ubyte 17
-        %tmp.3 = shr uint %tmp.2, ubyte 17              ; <uint> [#uses=1]
-        %tmp.5 = add uint %tmp.3, %x            ; <uint> [#uses=1]
-        %tmp.6 = shl uint %tmp.5, ubyte 17              ; <uint> [#uses=1]
-	ret uint %tmp.6
+define i32 @test25(i32 %tmp.2, i32 %AA) {
+        %x = lshr i32 %AA, 17           ; <i32> [#uses=1]
+        %tmp.3 = lshr i32 %tmp.2, 17            ; <i32> [#uses=1]
+        %tmp.5 = add i32 %tmp.3, %x             ; <i32> [#uses=1]
+        %tmp.6 = shl i32 %tmp.5, 17             ; <i32> [#uses=1]
+        ret i32 %tmp.6
 }
 
-int %test26(uint %A) { ;; handle casts between shifts.
-	%B = shr uint %A, ubyte 1
-	%C = cast uint %B to int
-        %D = shl int %C, ubyte 1
-	ret int %D
+;; handle casts between shifts.
+define i32 @test26(i32 %A) {
+        %B = lshr i32 %A, 1             ; <i32> [#uses=1]
+        %C = bitcast i32 %B to i32              ; <i32> [#uses=1]
+        %D = shl i32 %C, 1              ; <i32> [#uses=1]
+        ret i32 %D
 }
  
diff --git a/test/Transforms/InstCombine/shl-trunc.ll b/test/Transforms/InstCombine/shl-trunc.ll
index bfd41a87fc..ffef2984f5 100644
--- a/test/Transforms/InstCombine/shl-trunc.ll
+++ b/test/Transforms/InstCombine/shl-trunc.ll
@@ -1,7 +1,9 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep shl
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep shl
 
-bool %test(int %X, ubyte %A) {
-	%B = lshr int %X, ubyte %A
-	%D = trunc int %B to bool
-	ret bool %D
+define i1 @test(i32 %X, i8 %A) {
+        %shift.upgrd.1 = zext i8 %A to i32              ; <i32> [#uses=1]
+        %B = lshr i32 %X, %shift.upgrd.1                ; <i32> [#uses=1]
+        %D = trunc i32 %B to i1         ; <i1> [#uses=1]
+        ret i1 %D
 }
+
diff --git a/test/Transforms/InstCombine/signext.ll b/test/Transforms/InstCombine/signext.ll
index f69cbc0072..4828937e3e 100644
--- a/test/Transforms/InstCombine/signext.ll
+++ b/test/Transforms/InstCombine/signext.ll
@@ -1,44 +1,44 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep {(and\|xor\|add\|shl\|shr)}
-; END.
 
-int %test1(int %x) {
-        %tmp.1 = and int %x, 65535              ; <int> [#uses=1]
-        %tmp.2 = xor int %tmp.1, -32768         ; <int> [#uses=1]
-        %tmp.3 = add int %tmp.2, 32768          ; <int> [#uses=1]
-        ret int %tmp.3
+define i32 @test1(i32 %x) {
+        %tmp.1 = and i32 %x, 65535              ; <i32> [#uses=1]
+        %tmp.2 = xor i32 %tmp.1, -32768         ; <i32> [#uses=1]
+        %tmp.3 = add i32 %tmp.2, 32768          ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
-int %test2(int %x) {
-        %tmp.1 = and int %x, 65535              ; <int> [#uses=1]
-        %tmp.2 = xor int %tmp.1, 32768          ; <int> [#uses=1]
-        %tmp.3 = add int %tmp.2, -32768         ; <int> [#uses=1]
-        ret int %tmp.3
+define i32 @test2(i32 %x) {
+        %tmp.1 = and i32 %x, 65535              ; <i32> [#uses=1]
+        %tmp.2 = xor i32 %tmp.1, 32768          ; <i32> [#uses=1]
+        %tmp.3 = add i32 %tmp.2, -32768         ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
-int %test3(ushort %P) {
-        %tmp.1 = cast ushort %P to int          ; <int> [#uses=1]
-        %tmp.4 = xor int %tmp.1, 32768          ; <int> [#uses=1]
-        %tmp.5 = add int %tmp.4, -32768         ; <int> [#uses=1]
-        ret int %tmp.5
+define i32 @test3(i16 %P) {
+        %tmp.1 = zext i16 %P to i32             ; <i32> [#uses=1]
+        %tmp.4 = xor i32 %tmp.1, 32768          ; <i32> [#uses=1]
+        %tmp.5 = add i32 %tmp.4, -32768         ; <i32> [#uses=1]
+        ret i32 %tmp.5
 }
 
-uint %test4(ushort %P) {
-        %tmp.1 = cast ushort %P to uint         ; <uint> [#uses=1]
-        %tmp.4 = xor uint %tmp.1, 32768         ; <uint> [#uses=1]
-        %tmp.5 = add uint %tmp.4, 4294934528            ; <uint> [#uses=1]
-        ret uint %tmp.5
+define i32 @test4(i16 %P) {
+        %tmp.1 = zext i16 %P to i32             ; <i32> [#uses=1]
+        %tmp.4 = xor i32 %tmp.1, 32768          ; <i32> [#uses=1]
+        %tmp.5 = add i32 %tmp.4, -32768         ; <i32> [#uses=1]
+        ret i32 %tmp.5
 }
 
-int %test5(int %x) {
-	%tmp.1 = and int %x, 254
-	%tmp.2 = xor int %tmp.1, 128
-	%tmp.3 = add int %tmp.2, -128
-	ret int %tmp.3
+define i32 @test5(i32 %x) {
+        %tmp.1 = and i32 %x, 254                ; <i32> [#uses=1]
+        %tmp.2 = xor i32 %tmp.1, 128            ; <i32> [#uses=1]
+        %tmp.3 = add i32 %tmp.2, -128           ; <i32> [#uses=1]
+        ret i32 %tmp.3
 }
 
-int %test6(int %x) {
-        %tmp.2 = shl int %x, ubyte 16           ; <int> [#uses=1]
-        %tmp.4 = shr int %tmp.2, ubyte 16               ; <int> [#uses=1]
-        ret int %tmp.4
+define i32 @test6(i32 %x) {
+        %tmp.2 = shl i32 %x, 16         ; <i32> [#uses=1]
+        %tmp.4 = ashr i32 %tmp.2, 16            ; <i32> [#uses=1]
+        ret i32 %tmp.4
 }
+
diff --git a/test/Transforms/InstCombine/sink_instruction.ll b/test/Transforms/InstCombine/sink_instruction.ll
index 93519ffdc0..cb8a090e5a 100644
--- a/test/Transforms/InstCombine/sink_instruction.ll
+++ b/test/Transforms/InstCombine/sink_instruction.ll
@@ -1,18 +1,19 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   %prcontext div 1 | grep ret
 
 ;; This tests that the instructions in the entry blocks are sunk into each
 ;; arm of the 'if'.
 
-int %foo(bool %C, int %A, int %B) {
+define i32 @foo(i1 %C, i32 %A, i32 %B) {
 entry:
-	%tmp.2 = div int %A, %B
-	%tmp.9 = add int %B, %A
-	br bool %C, label %then, label %endif
+        %tmp.2 = sdiv i32 %A, %B                ; <i32> [#uses=1]
+        %tmp.9 = add i32 %B, %A         ; <i32> [#uses=1]
+        br i1 %C, label %then, label %endif
 
-then:
-	ret int %tmp.9
+then:           ; preds = %entry
+        ret i32 %tmp.9
 
-endif:
-	ret int %tmp.2
+endif:          ; preds = %entry
+        ret i32 %tmp.2
 }
+
diff --git a/test/Transforms/InstCombine/store.ll b/test/Transforms/InstCombine/store.ll
index 0b7d12f547..337b2cce08 100644
--- a/test/Transforms/InstCombine/store.ll
+++ b/test/Transforms/InstCombine/store.ll
@@ -1,16 +1,17 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep -v {store.*,.*null} | not grep store
 
-void %test1(int* %P) {
-	store int undef, int* %P
-	store int 123, int* undef
-	store int 124, int* null
-	ret void
+define void @test1(i32* %P) {
+        store i32 undef, i32* %P
+        store i32 123, i32* undef
+        store i32 124, i32* null
+        ret void
 }
 
-void %test2(int* %P) {
-	%X = load int* %P
-	%Y = add int %X, 0
-	store int %Y, int* %P
-	ret void
+define void @test2(i32* %P) {
+        %X = load i32* %P               ; <i32> [#uses=1]
+        %Y = add i32 %X, 0              ; <i32> [#uses=1]
+        store i32 %Y, i32* %P
+        ret void
 }
+
diff --git a/test/Transforms/InstCombine/sub.ll b/test/Transforms/InstCombine/sub.ll
index dfee31253f..9ee8b06845 100644
--- a/test/Transforms/InstCombine/sub.ll
+++ b/test/Transforms/InstCombine/sub.ll
@@ -1,139 +1,136 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep -v {sub i32 %Cok, %Bok} | not grep sub
 
-implementation
-
-int %test1(int %A) {
-	%B = sub int %A, %A    ; ISA constant 0
-	ret int %B
+define i32 @test1(i32 %A) {
+	%B = sub i32 %A, %A		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test2(int %A) {
-	%B = sub int %A, 0
-	ret int %B
+define i32 @test2(i32 %A) {
+	%B = sub i32 %A, 0		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test3(int %A) {
-	%B = sub int 0, %A       ; B = -A
-	%C = sub int 0, %B       ; C = -B = A
-	ret int %C
+define i32 @test3(i32 %A) {
+	%B = sub i32 0, %A		; <i32> [#uses=1]
+	%C = sub i32 0, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test4(int %A, int %x) {
-	%B = sub int 0, %A
-	%C = sub int %x, %B
-	ret int %C
+define i32 @test4(i32 %A, i32 %x) {
+	%B = sub i32 0, %A		; <i32> [#uses=1]
+	%C = sub i32 %x, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test5(int %A, int %Bok, int %Cok) {
-	%D = sub int %Bok, %Cok
-	%E = sub int %A, %D
-	ret int %E
+define i32 @test5(i32 %A, i32 %Bok, i32 %Cok) {
+	%D = sub i32 %Bok, %Cok		; <i32> [#uses=1]
+	%E = sub i32 %A, %D		; <i32> [#uses=1]
+	ret i32 %E
 }
 
-int %test6(int %A, int %B) {
-	%C = and int %A, %B   ; A - (A & B) => A & ~B
-	%D = sub int %A, %C
-	ret int %D
+define i32 @test6(i32 %A, i32 %B) {
+	%C = and i32 %A, %B		; <i32> [#uses=1]
+	%D = sub i32 %A, %C		; <i32> [#uses=1]
+	ret i32 %D
 }
 
-int %test7(int %A) {
-	%B = sub int -1, %A   ; B = ~A
-	ret int %B
+define i32 @test7(i32 %A) {
+	%B = sub i32 -1, %A		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test8(int %A) {
-        %B = mul int 9, %A
-        %C = sub int %B, %A      ; C = 9*A-A == A*8 == A << 3
-        ret int %C
+define i32 @test8(i32 %A) {
+	%B = mul i32 9, %A		; <i32> [#uses=1]
+	%C = sub i32 %B, %A		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test9(int %A) {
-        %B = mul int 3, %A
-        %C = sub int %A, %B      ; C = A-3*A == A*-2
-        ret int %C
+define i32 @test9(i32 %A) {
+	%B = mul i32 3, %A		; <i32> [#uses=1]
+	%C = sub i32 %A, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test10(int %A, int %B) {    ; -A*-B == A*B
-	%C = sub int 0, %A
-	%D = sub int 0, %B
-	%E = mul int %C, %D
-	ret int %E
+define i32 @test10(i32 %A, i32 %B) {
+	%C = sub i32 0, %A		; <i32> [#uses=1]
+	%D = sub i32 0, %B		; <i32> [#uses=1]
+	%E = mul i32 %C, %D		; <i32> [#uses=1]
+	ret i32 %E
 }
 
-int %test10(int %A) {    ; -A *c1 == A * -c1
-	%C = sub int 0, %A
-	%E = mul int %C, 7
-	ret int %E
+define i32 @test10.upgrd.1(i32 %A) {
+	%C = sub i32 0, %A		; <i32> [#uses=1]
+	%E = mul i32 %C, 7		; <i32> [#uses=1]
+	ret i32 %E
 }
 
-bool %test11(ubyte %A, ubyte %B) {
-        %C = sub ubyte %A, %B
-        %cD = setne ubyte %C, 0    ; == setne A, B
-        ret bool %cD
+define i1 @test11(i8 %A, i8 %B) {
+	%C = sub i8 %A, %B		; <i8> [#uses=1]
+	%cD = icmp ne i8 %C, 0		; <i1> [#uses=1]
+	ret i1 %cD
 }
 
-int %test12(int %A) {
-	%B = shr int %A, ubyte 31
-	%C = sub int 0, %B         ; == ushr A, 31
-	ret int %C 
+define i32 @test12(i32 %A) {
+	%B = ashr i32 %A, 31		; <i32> [#uses=1]
+	%C = sub i32 0, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test13(uint %A) {
-	%B = shr uint %A, ubyte 31
-	%C = sub uint 0, %B        ; == sar A, 31
-	ret uint %C
+define i32 @test13(i32 %A) {
+	%B = lshr i32 %A, 31		; <i32> [#uses=1]
+	%C = sub i32 0, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-int %test14(uint %A) {
-        %B = shr uint %A, ubyte 31
-        %C = cast uint %B to int
-        %D = sub int 0, %C
-        ret int %D
+define i32 @test14(i32 %A) {
+	%B = lshr i32 %A, 31		; <i32> [#uses=1]
+	%C = bitcast i32 %B to i32		; <i32> [#uses=1]
+	%D = sub i32 0, %C		; <i32> [#uses=1]
+	ret i32 %D
 }
 
-int %test15(int %A, int %B) {
-	%C = sub int 0, %A
-	%D = rem int %B, %C   ;; X % -Y === X % Y
-	ret int %D
+define i32 @test15(i32 %A, i32 %B) {
+	%C = sub i32 0, %A		; <i32> [#uses=1]
+	%D = srem i32 %B, %C		; <i32> [#uses=1]
+	ret i32 %D
 }
 
-int %test16(int %A) {
-	%X = div int %A, 1123
-	%Y = sub int 0, %X
-	ret int %Y
+define i32 @test16(i32 %A) {
+	%X = sdiv i32 %A, 1123		; <i32> [#uses=1]
+	%Y = sub i32 0, %X		; <i32> [#uses=1]
+	ret i32 %Y
 }
 
-int %test17(int %A) {
-	%B = sub int 0, %A
-	%C = div int %B, 1234
-	ret int %C
+define i32 @test17(i32 %A) {
+	%B = sub i32 0, %A		; <i32> [#uses=1]
+	%C = sdiv i32 %B, 1234		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-long %test18(long %Y) {
-        %tmp.4 = shl long %Y, ubyte 2
-        %tmp.12 = shl long %Y, ubyte 2
-        %tmp.8 = sub long %tmp.4, %tmp.12 ;; 0
-        ret long %tmp.8
+define i64 @test18(i64 %Y) {
+	%tmp.4 = shl i64 %Y, 2		; <i64> [#uses=1]
+	%tmp.12 = shl i64 %Y, 2		; <i64> [#uses=1]
+	%tmp.8 = sub i64 %tmp.4, %tmp.12		; <i64> [#uses=1]
+	ret i64 %tmp.8
 }
 
-int %test19(int %X, int %Y) {
-	%Z = sub int %X, %Y
-	%Q = add int %Z, %Y
-	ret int %Q
+define i32 @test19(i32 %X, i32 %Y) {
+	%Z = sub i32 %X, %Y		; <i32> [#uses=1]
+	%Q = add i32 %Z, %Y		; <i32> [#uses=1]
+	ret i32 %Q
 }
 
-bool %test20(int %g, int %h) {
-        %tmp.2 = sub int %g, %h
-        %tmp.4 = setne int %tmp.2, %g
-        ret bool %tmp.4
+define i1 @test20(i32 %g, i32 %h) {
+	%tmp.2 = sub i32 %g, %h		; <i32> [#uses=1]
+	%tmp.4 = icmp ne i32 %tmp.2, %g		; <i1> [#uses=1]
+	ret i1 %tmp.4
 }
 
-bool %test21(int %g, int %h) {
-        %tmp.2 = sub int %g, %h
-        %tmp.4 = setne int %tmp.2, %g
-        ret bool %tmp.4
+define i1 @test21(i32 %g, i32 %h) {
+	%tmp.2 = sub i32 %g, %h		; <i32> [#uses=1]
+	%tmp.4 = icmp ne i32 %tmp.2, %g		; <i1> [#uses=1]
+	ret i1 %tmp.4
 }
-
diff --git a/test/Transforms/InstCombine/vec_insert_to_shuffle.ll b/test/Transforms/InstCombine/vec_insert_to_shuffle.ll
index 04d3ee56eb..5f0ce6566d 100644
--- a/test/Transforms/InstCombine/vec_insert_to_shuffle.ll
+++ b/test/Transforms/InstCombine/vec_insert_to_shuffle.ll
@@ -1,18 +1,18 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep shufflevec | count 1
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   not grep insertelement
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   not grep extractelement
-; END.
 
-<4 x float> %test(<4 x float> %tmp, <4 x float> %tmp1) {
-	%tmp4 = extractelement <4 x float> %tmp, uint 1		; <float> [#uses=1]
-	%tmp2 = extractelement <4 x float> %tmp, uint 3		; <float> [#uses=1]
-	%tmp1 = extractelement <4 x float> %tmp1, uint 0		; <float> [#uses=1]
-	%tmp128 = insertelement <4 x float> undef, float %tmp4, uint 0		; <<4 x float>> [#uses=1]
-	%tmp130 = insertelement <4 x float> %tmp128, float undef, uint 1		; <<4 x float>> [#uses=1]
-	%tmp132 = insertelement <4 x float> %tmp130, float %tmp2, uint 2		; <<4 x float>> [#uses=1]
-	%tmp134 = insertelement <4 x float> %tmp132, float %tmp1, uint 3		; <<4 x float>> [#uses=1]
-	ret <4 x float> %tmp134
+define <4 x float> @test(<4 x float> %tmp, <4 x float> %tmp1) {
+        %tmp4 = extractelement <4 x float> %tmp, i32 1          ; <float> [#uses=1]
+        %tmp2 = extractelement <4 x float> %tmp, i32 3          ; <float> [#uses=1]
+        %tmp1.upgrd.1 = extractelement <4 x float> %tmp1, i32 0         ; <float> [#uses=1]
+        %tmp128 = insertelement <4 x float> undef, float %tmp4, i32 0           ; <<4 x float>> [#uses=1]
+        %tmp130 = insertelement <4 x float> %tmp128, float undef, i32 1         ; <<4 x float>> [#uses=1]
+        %tmp132 = insertelement <4 x float> %tmp130, float %tmp2, i32 2         ; <<4 x float>> [#uses=1]
+        %tmp134 = insertelement <4 x float> %tmp132, float %tmp1.upgrd.1, i32 3         ; <<4 x float>> [#uses=1]
+        ret <4 x float> %tmp134
 }
+
diff --git a/test/Transforms/InstCombine/vec_narrow.ll b/test/Transforms/InstCombine/vec_narrow.ll
index ca94b081d7..9063148424 100644
--- a/test/Transforms/InstCombine/vec_narrow.ll
+++ b/test/Transforms/InstCombine/vec_narrow.ll
@@ -1,12 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep {add float}
 
-%V = type <4 x float>
+        %V = type <4 x float>
 
-float %test(%V %A, %V %B, float %f) {
-        %C = insertelement %V %A, float %f, uint 0
-        %D = add %V %C, %B
-        %E = extractelement %V %D, uint 0
+define float @test(%V %A, %V %B, float %f) {
+        %C = insertelement %V %A, float %f, i32 0               ; <%V> [#uses=1]
+        %D = add %V %C, %B              ; <%V> [#uses=1]
+        %E = extractelement %V %D, i32 0                ; <float> [#uses=1]
         ret float %E
 }
 
diff --git a/test/Transforms/InstCombine/xor.ll b/test/Transforms/InstCombine/xor.ll
index e2011499cc..87e2cef3a1 100644
--- a/test/Transforms/InstCombine/xor.ll
+++ b/test/Transforms/InstCombine/xor.ll
@@ -1,198 +1,192 @@
 ; This test makes sure that these instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep {xor }
-; END.
+@G1 = global i32 0		; <i32*> [#uses=1]
+@G2 = global i32 0		; <i32*> [#uses=1]
 
-%G1 = global uint 0
-%G2 = global uint 0
-
-implementation
+define i1 @test0(i1 %A) {
+	%B = xor i1 %A, false		; <i1> [#uses=1]
+	ret i1 %B
+}
 
-bool %test0(bool %A) {
-	%B = xor bool %A, false
-	ret bool %B
+define i32 @test1(i32 %A) {
+	%B = xor i32 %A, 0		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test1(int %A) {
-	%B = xor int %A, 0
-	ret int %B
+define i1 @test2(i1 %A) {
+	%B = xor i1 %A, %A		; <i1> [#uses=1]
+	ret i1 %B
 }
 
-bool %test2(bool %A) {
-	%B = xor bool %A, %A
-	ret bool %B
+define i32 @test3(i32 %A) {
+	%B = xor i32 %A, %A		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test3(int %A) {
-	%B = xor int %A, %A
-	ret int %B
+define i32 @test4(i32 %A) {
+	%NotA = xor i32 -1, %A		; <i32> [#uses=1]
+	%B = xor i32 %A, %NotA		; <i32> [#uses=1]
+	ret i32 %B
 }
 
-int %test4(int %A) {    ; A ^ ~A == -1
-        %NotA = xor int -1, %A
-        %B = xor int %A, %NotA
-        ret int %B
+define i32 @test5(i32 %A) {
+	%t1 = or i32 %A, 123		; <i32> [#uses=1]
+	%r = xor i32 %t1, 123		; <i32> [#uses=1]
+	ret i32 %r
 }
 
-uint %test5(uint %A) { ; (A|B)^B == A & (~B)
-	%t1 = or uint %A, 123
-	%r  = xor uint %t1, 123
-	ret uint %r
+define i8 @test6(i8 %A) {
+	%B = xor i8 %A, 17		; <i8> [#uses=1]
+	%C = xor i8 %B, 17		; <i8> [#uses=1]
+	ret i8 %C
 }
 
-ubyte %test6(ubyte %A) {
-	%B = xor ubyte %A, 17
-	%C = xor ubyte %B, 17
-	ret ubyte %C
+define i32 @test7(i32 %A, i32 %B) {
+	%A1 = and i32 %A, 7		; <i32> [#uses=1]
+	%B1 = and i32 %B, 128		; <i32> [#uses=1]
+	%C1 = xor i32 %A1, %B1		; <i32> [#uses=1]
+	ret i32 %C1
 }
 
-; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
-int %test7(int %A, int %B) {
+define i8 @test8(i1 %c) {
+	%d = xor i1 %c, true		; <i1> [#uses=1]
+	br i1 %d, label %True, label %False
 
-        %A1 = and int %A, 7
-        %B1 = and int %B, 128
-        %C1 = xor int %A1, %B1
-        ret int %C1
-}
+True:		; preds = %0
+	ret i8 1
 
-ubyte %test8(bool %c) {
-	%d = xor bool %c, true    ; invert the condition
-	br bool %d, label %True, label %False
-True:
-	ret ubyte 1
-False:
-	ret ubyte 3
+False:		; preds = %0
+	ret i8 3
 }
 
-bool %test9(ubyte %A) {
-	%B = xor ubyte %A, 123      ; xor can be eliminated
-	%C = seteq ubyte %B, 34
-	ret bool %C
+define i1 @test9(i8 %A) {
+	%B = xor i8 %A, 123		; <i8> [#uses=1]
+	%C = icmp eq i8 %B, 34		; <i1> [#uses=1]
+	ret i1 %C
 }
 
-ubyte %test10(ubyte %A) {
-	%B = and ubyte %A, 3
-	%C = xor ubyte %B, 4        ; transform into an OR
-	ret ubyte %C
+define i8 @test10(i8 %A) {
+	%B = and i8 %A, 3		; <i8> [#uses=1]
+	%C = xor i8 %B, 4		; <i8> [#uses=1]
+	ret i8 %C
 }
 
-ubyte %test11(ubyte %A) {
-	%B = or ubyte %A, 12
-	%C = xor ubyte %B, 4        ; transform into an AND
-	ret ubyte %C
+define i8 @test11(i8 %A) {
+	%B = or i8 %A, 12		; <i8> [#uses=1]
+	%C = xor i8 %B, 4		; <i8> [#uses=1]
+	ret i8 %C
 }
 
-bool %test12(ubyte %A) {
-	%B = xor ubyte %A, 4
-	%c = setne ubyte %B, 0
-	ret bool %c
+define i1 @test12(i8 %A) {
+	%B = xor i8 %A, 4		; <i8> [#uses=1]
+	%c = icmp ne i8 %B, 0		; <i1> [#uses=1]
+	ret i1 %c
 }
 
-bool %test13(ubyte %A, ubyte %B) {
-	%C = setlt ubyte %A, %B
-	%D = setgt ubyte %A, %B
-	%E = xor bool %C, %D        ; E = setne %A, %B
-	ret bool %E
+define i1 @test13(i8 %A, i8 %B) {
+	%C = icmp ult i8 %A, %B		; <i1> [#uses=1]
+	%D = icmp ugt i8 %A, %B		; <i1> [#uses=1]
+	%E = xor i1 %C, %D		; <i1> [#uses=1]
+	ret i1 %E
 }
 
-bool %test14(ubyte %A, ubyte %B) {
-	%C = seteq ubyte %A, %B
-	%D = setne ubyte %B, %A
-	%E = xor bool %C, %D        ; E = true
-	ret bool %E
+define i1 @test14(i8 %A, i8 %B) {
+	%C = icmp eq i8 %A, %B		; <i1> [#uses=1]
+	%D = icmp ne i8 %B, %A		; <i1> [#uses=1]
+	%E = xor i1 %C, %D		; <i1> [#uses=1]
+	ret i1 %E
 }
 
-uint %test15(uint %A) {             ; ~(X-1) == -X
-	%B = add uint %A, 4294967295
-	%C = xor uint %B, 4294967295
-	ret uint %C
+define i32 @test15(i32 %A) {
+	%B = add i32 %A, -1		; <i32> [#uses=1]
+	%C = xor i32 %B, -1		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test16(uint %A) {             ; ~(X+c) == (-c-1)-X
-	%B = add uint %A, 123       ; A generalization of the previous case
-	%C = xor uint %B, 4294967295
-	ret uint %C
+define i32 @test16(i32 %A) {
+	%B = add i32 %A, 123		; <i32> [#uses=1]
+	%C = xor i32 %B, -1		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test17(uint %A) {             ; ~(c-X) == X-(c-1) == X+(-c+1)
-	%B = sub uint 123, %A
-	%C = xor uint %B, 4294967295
-	ret uint %C
+define i32 @test17(i32 %A) {
+	%B = sub i32 123, %A		; <i32> [#uses=1]
+	%C = xor i32 %B, -1		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test18(uint %A) {             ; C - ~X == X + (1+C)
-	%B = xor uint %A, 4294967295; -~X == 0 - ~X == X+1
-	%C = sub uint 123, %B
-	ret uint %C
+define i32 @test18(i32 %A) {
+	%B = xor i32 %A, -1		; <i32> [#uses=1]
+	%C = sub i32 123, %B		; <i32> [#uses=1]
+	ret i32 %C
 }
 
-uint %test19(uint %A, uint %B) {
-	%C = xor uint %A, %B
-	%D = xor uint %C, %A  ; A terms cancel, D = B
-	ret uint %D
+define i32 @test19(i32 %A, i32 %B) {
+	%C = xor i32 %A, %B		; <i32> [#uses=1]
+	%D = xor i32 %C, %A		; <i32> [#uses=1]
+	ret i32 %D
 }
 
-void %test20(uint %A, uint %B) {  ; The "swap idiom"
-        %tmp.2 = xor uint %B, %A
-        %tmp.5 = xor uint %tmp.2, %B
-        %tmp.8 = xor uint %tmp.5, %tmp.2
-        store uint %tmp.8, uint* %G1   ; tmp.8 = B
-        store uint %tmp.5, uint* %G2   ; tmp.5 = A
-        ret void
+define void @test20(i32 %A, i32 %B) {
+	%tmp.2 = xor i32 %B, %A		; <i32> [#uses=2]
+	%tmp.5 = xor i32 %tmp.2, %B		; <i32> [#uses=2]
+	%tmp.8 = xor i32 %tmp.5, %tmp.2		; <i32> [#uses=1]
+	store i32 %tmp.8, i32* @G1
+	store i32 %tmp.5, i32* @G2
+	ret void
 }
 
-int %test21(bool %C, int %A, int %B) {
-	%C2 = xor bool %C, true
-	%D = select bool %C2, int %A, int %B
-	ret int %D
+define i32 @test21(i1 %C, i32 %A, i32 %B) {
+	%C2 = xor i1 %C, true		; <i1> [#uses=1]
+	%D = select i1 %C2, i32 %A, i32 %B		; <i32> [#uses=1]
+	ret i32 %D
 }
 
-int %test22(bool %X) {
-        %Y = xor bool %X, true
-        %Z = cast bool %Y to int
-        %Q = xor int %Z, 1
-        ret int %Q
+define i32 @test22(i1 %X) {
+	%Y = xor i1 %X, true		; <i1> [#uses=1]
+	%Z = zext i1 %Y to i32		; <i32> [#uses=1]
+	%Q = xor i32 %Z, 1		; <i32> [#uses=1]
+	ret i32 %Q
 }
 
-bool %test23(int %a, int %b) {
-        %tmp.2 = xor int %b, %a
-        %tmp.4 = seteq int %tmp.2, %a
-        ret bool %tmp.4
+define i1 @test23(i32 %a, i32 %b) {
+	%tmp.2 = xor i32 %b, %a		; <i32> [#uses=1]
+	%tmp.4 = icmp eq i32 %tmp.2, %a		; <i1> [#uses=1]
+	ret i1 %tmp.4
 }
 
-bool %test24(int %c, int %d) {
-        %tmp.2 = xor int %d, %c
-        %tmp.4 = setne int %tmp.2, %c
-        ret bool %tmp.4
+define i1 @test24(i32 %c, i32 %d) {
+	%tmp.2 = xor i32 %d, %c		; <i32> [#uses=1]
+	%tmp.4 = icmp ne i32 %tmp.2, %c		; <i1> [#uses=1]
+	ret i1 %tmp.4
 }
 
-int %test25(int %g, int %h) {
-	%h2 = xor int %h, -1
-        %tmp2 = and int %h2, %g
-        %tmp4 = xor int %tmp2, %g  ; (h2&g)^g -> ~h2 & g -> h & g
-        ret int %tmp4
+define i32 @test25(i32 %g, i32 %h) {
+	%h2 = xor i32 %h, -1		; <i32> [#uses=1]
+	%tmp2 = and i32 %h2, %g		; <i32> [#uses=1]
+	%tmp4 = xor i32 %tmp2, %g		; <i32> [#uses=1]
+	ret i32 %tmp4
 }
 
-int %test26(int %a, int %b) {
-	%b2 = xor int %b, -1
-        %tmp2 = xor int %a, %b2
-        %tmp4 = and int %tmp2, %a  ; (a^b2)&a -> ~b2 & a -> b & a
-        ret int %tmp4
+define i32 @test26(i32 %a, i32 %b) {
+	%b2 = xor i32 %b, -1		; <i32> [#uses=1]
+	%tmp2 = xor i32 %a, %b2		; <i32> [#uses=1]
+	%tmp4 = and i32 %tmp2, %a		; <i32> [#uses=1]
+	ret i32 %tmp4
 }
 
-
-int %test27(int %b, int %c, int %d) {
-        %tmp2 = xor int %d, %b
-        %tmp5 = xor int %d, %c
-        %tmp = icmp eq int %tmp2, %tmp5
-        %tmp6 = zext bool %tmp to int
-        ret int %tmp6
+define i32 @test27(i32 %b, i32 %c, i32 %d) {
+	%tmp2 = xor i32 %d, %b		; <i32> [#uses=1]
+	%tmp5 = xor i32 %d, %c		; <i32> [#uses=1]
+	%tmp = icmp eq i32 %tmp2, %tmp5		; <i1> [#uses=1]
+	%tmp6 = zext i1 %tmp to i32		; <i32> [#uses=1]
+	ret i32 %tmp6
 }
 
-int %test28(int %indvar) {
-        %tmp7 = add int %indvar, -2147483647
-        %tmp214 = xor int %tmp7, -2147483648
-        ret int %tmp214
+define i32 @test28(i32 %indvar) {
+	%tmp7 = add i32 %indvar, -2147483647		; <i32> [#uses=1]
+	%tmp214 = xor i32 %tmp7, -2147483648		; <i32> [#uses=1]
+	ret i32 %tmp214
 }
-
diff --git a/test/Transforms/InstCombine/zeroext-and-reduce.ll b/test/Transforms/InstCombine/zeroext-and-reduce.ll
index aac8c3bd7f..2b4950aec9 100644
--- a/test/Transforms/InstCombine/zeroext-and-reduce.ll
+++ b/test/Transforms/InstCombine/zeroext-and-reduce.ll
@@ -1,9 +1,10 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   grep {and i32 %Y, 8}
 
-int %test1(ubyte %X) {
-        %Y = cast ubyte %X to int
-        %Z = and int %Y, 65544     ;; Prune this to and Y, 8
-        ret int %Z
+define i32 @test1(i8 %X) {
+        %Y = zext i8 %X to i32          ; <i32> [#uses=1]
+        %Z = and i32 %Y, 65544          ; <i32> [#uses=1]
+        ret i32 %Z
 }
 
+
diff --git a/test/Transforms/InstCombine/zext.ll b/test/Transforms/InstCombine/zext.ll
index cd1f1f827b..ceb8deb677 100644
--- a/test/Transforms/InstCombine/zext.ll
+++ b/test/Transforms/InstCombine/zext.ll
@@ -1,9 +1,10 @@
 ; Tests to make sure elimination of casts is working correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:   notcast {} {%c1.*}
 
-long %test_sext_zext(short %A) {
-    %c1 = zext short %A to uint
-    %c2 = sext uint %c1 to long
-    ret long %c2
+define i64 @test_sext_zext(i16 %A) {
+        %c1 = zext i16 %A to i32                ; <i32> [#uses=1]
+        %c2 = sext i32 %c1 to i64               ; <i64> [#uses=1]
+        ret i64 %c2
 }
+