target triple = "x86_64-pc-linux-gnu"
%.type.opaque = type opaque

@xs.2 = internal global ptr zeroinitializer
define internal i32 @icmp.4(ptr %lhs, ptr %rhs, ptr %_) { 
%lhs.0 = alloca ptr   store ptr %lhs, ptr %lhs.0
%rhs.1 = alloca ptr   store ptr %rhs, ptr %rhs.1
%_.2 = alloca ptr   store ptr %_, ptr %_.2
	%lhs.3 = alloca i32
	%t1 = load ptr, ptr %lhs.0
	%t0 = bitcast ptr %t1 to ptr
	%t2 = load i32, ptr %t0
	store i32 %t2, ptr %lhs.3
	%rhs.4 = alloca i32
	%t4 = load ptr, ptr %rhs.1
	%t3 = bitcast ptr %t4 to ptr
	%t5 = load i32, ptr %t3
	store i32 %t5, ptr %rhs.4
	%t6 = load i32, ptr %lhs.3
	%t7 = load i32, ptr %rhs.4
	%t8 = sub i32 %t6, %t7
	ret i32 %t8
	ret i32 undef
}
define internal void @foo.5() { 
	ret void
}
define internal void @isort.3(ptr %xs, i64 %n) { 
%xs.0 = alloca ptr   store ptr %xs, ptr %xs.0
%n.1 = alloca i64   store i64 %n, ptr %n.1
	%t1 = load ptr, ptr %xs.0
	%t0 = bitcast ptr %t1 to ptr
	%t2 = load i64, ptr %n.1
	%t3 = sext i32 4 to i64
	call void(ptr, i64, i64, ptr)  @qsort(ptr %t0, i64 %t2, i64 %t3, ptr @icmp.4)
	%x.2 = alloca ptr
	store ptr @foo.5, ptr %x.2
	%t4 = load ptr, ptr %x.2
	call ptr %t4()
	ret void
}
define internal i64 @length.7(ptr %l) { 
%l.0 = alloca ptr   store ptr %l, ptr %l.0
	%n.1 = alloca i64
	store i64 0, ptr %n.1
	%t0 = load ptr, ptr %l.0
	%t1 = load { ptr, i32 }, ptr %t0
	call void({ ptr, i32 })  @ok.6({ ptr, i32 } %t1)
	br label %Cont1
Cont1:	%t2 = bitcast i8 0 to i8 ; NOP
	%t3 = load ptr, ptr %l.0
	%t4 = icmp ne ptr %t3, null
	br i1 %t4, label %Next1, label %Brk1
Next1:	%t5 = bitcast i8 0 to i8 ; NOP
	%t6 = load i64, ptr %n.1
	%t7 = add i64 %t6, 1
	store i64 %t7, ptr %n.1
	%t9 = load ptr, ptr %l.0
	%t10 = getelementptr { ptr, i32 }, ptr %t9, i32 0, i32 0
	%t8 = load ptr, ptr %t10
	store ptr %t8, ptr %l.0
	br label %Cont1
Brk1:	%t11 = bitcast i8 0 to i8 ; NOP
	%t12 = load i64, ptr %n.1
	ret i64 %t12
	ret i64 undef
}
define internal void @ok.8({ ptr, i32 } %l) { 
%l.0 = alloca { ptr, i32 }   store { ptr, i32 } %l, ptr %l.0
	ret void
}
define internal float @mag.9({ float, float } %v) { 
%v.0 = alloca { float, float }   store { float, float } %v, ptr %v.0
	%t1 = getelementptr { float, float }, ptr %v.0, i32 0, i32 0
	%t0 = load float, ptr %t1
	%t3 = getelementptr { float, float }, ptr %v.0, i32 0, i32 0
	%t2 = load float, ptr %t3
	%t4 = fmul float %t0, %t2
	%t6 = getelementptr { float, float }, ptr %v.0, i32 0, i32 1
	%t5 = load float, ptr %t6
	%t8 = getelementptr { float, float }, ptr %v.0, i32 0, i32 1
	%t7 = load float, ptr %t8
	%t9 = fmul float %t5, %t7
	%t10 = fadd float %t4, %t9
	%t11 = call float(float)  @sqrtf(float %t10)
	ret float %t11
	ret float undef
}
define internal void @zero.11(ptr %v) { 
%v.0 = alloca ptr   store ptr %v, ptr %v.0
	%t0 = load ptr, ptr %v.0
	%t1 = getelementptr { float, float }, ptr %t0, i32 0, i32 0
	%t2 = sitofp i32 0 to float
	store float %t2, ptr %t1
	%t3 = load ptr, ptr %v.0
	%t4 = getelementptr { float, float }, ptr %t3, i32 0, i32 1
	%t5 = sitofp i32 0 to float
	store float %t5, ptr %t4
	ret void
}
define internal { ptr, i64 } @spanz.12(ptr %cstr) { 
%cstr.0 = alloca ptr   store ptr %cstr, ptr %cstr.0
	%t0 = load ptr, ptr %cstr.0
	%t1 = sext i32 0 to i64
	%t2 = load ptr, ptr %cstr.0
	%t3 = call i64(ptr)  @strlen(ptr %t2)
	%t4 = sub i64 %t3, %t1
	%t5 = insertvalue { ptr, i64 } undef, ptr %t0, 0
	%t6 = insertvalue { ptr, i64 } %t5, i64 %t4, 1
	ret { ptr, i64 } %t6
	ret { ptr, i64 } undef
}
define i32 @main(i32 %argc, ptr %argv) { 
%argc.0 = alloca i32   store i32 %argc, ptr %argc.0
%argv.1 = alloca ptr   store ptr %argv, ptr %argv.1
	%colors.2 = alloca [3 x i16]
	%t0 = alloca [3 x i16]
	store [3 x i16] zeroinitializer, ptr %t0
	%t1 = getelementptr [3 x i16], ptr %t0, i32 0, i32 0
	store i16 0, ptr %t1
	%t2 = getelementptr [3 x i16], ptr %t0, i32 0, i32 1
	store i16 1, ptr %t2
	%t3 = getelementptr [3 x i16], ptr %t0, i32 0, i32 2
	store i16 2, ptr %t3
	%t4 = load [3 x i16], ptr %t0
	store [3 x i16] %t4, ptr %colors.2
	%x.3 = alloca { float, float }
	%t5 = alloca { float, float }
	store { float, float } zeroinitializer, ptr %t5
	%t6 = getelementptr { float, float }, ptr %t5, i32 0, i32 1
	%t7 = sitofp i32 1 to float
	store float %t7, ptr %t6
	%t8 = getelementptr { float, float }, ptr %t5, i32 0, i32 0
	%t9 = fptrunc double 2.39999999999999991118216 to float
	store float %t9, ptr %t8
	%t10 = load { float, float }, ptr %t5
	store { float, float } %t10, ptr %x.3
	%p.4 = alloca ptr
	%t11 = bitcast ptr %x.3 to ptr
	store ptr %t11, ptr %p.4
	%t12 = getelementptr [16 x i8], ptr @.str.0, i64 0, i64 0
	%t14 = getelementptr { float, float }, ptr %x.3, i32 0, i32 0
	%t13 = load float, ptr %t14
	%t16 = load ptr, ptr %p.4
	%t17 = getelementptr { float, float }, ptr %t16, i32 0, i32 1
	%t15 = load float, ptr %t17
	%t18 = call i32(ptr, ...)  @printf(ptr %t12, float %t13, float %t15)
	%t19 = getelementptr [10 x i8], ptr @.str.1, i64 0, i64 0
	%t20 = load { float, float }, ptr %x.3
	%t21 = call float({ float, float })  @mag.9({ float, float } %t20)
	%t22 = call i32(ptr, ...)  @printf(ptr %t19, float %t21)
	call void(ptr)  @zero.11(ptr %x.3)
	%t23 = getelementptr [10 x i8], ptr @.str.2, i64 0, i64 0
	%t24 = load { float, float }, ptr %x.3
	%t25 = call float({ float, float })  @mag.9({ float, float } %t24)
	%t26 = call i32(ptr, ...)  @printf(ptr %t23, float %t25)
	%x.5 = alloca { i8,  i64 }
	%t27 = alloca { i8,  i64 }
	store { i8,  i64 } zeroinitializer, ptr %t27
	store i8 0, ptr %t27
	%t28 = load { i8,  i64 }, ptr %t27
	store { i8,  i64 } %t28, ptr %x.5
	%x.6 = alloca { i8,  i64 }
	%t29 = alloca { i8,  i64 }
	store { i8,  i64 } zeroinitializer, ptr %t29
	store i8 1, ptr %t29
	%t30 = bitcast ptr %t29 to ptr
	%t31 = getelementptr i64, ptr %t30, i32 1
	store i64 zeroinitializer, ptr %t31
	%t32 = load { i8,  i64 }, ptr %t29
	store { i8,  i64 } %t32, ptr %x.6
	%is.7 = alloca [6 x i32]
	%t33 = alloca [6 x i32]
	store [6 x i32] zeroinitializer, ptr %t33
	%t34 = getelementptr [6 x i32], ptr %t33, i32 0, i32 4
	store i32 1, ptr %t34
	%t35 = getelementptr [6 x i32], ptr %t33, i32 0, i32 5
	store i32 2, ptr %t35
	%t36 = getelementptr [6 x i32], ptr %t33, i32 0, i32 0
	store i32 3, ptr %t36
	%t37 = load [6 x i32], ptr %t33
	store [6 x i32] %t37, ptr %is.7
	%t38 = getelementptr [6 x i32], ptr %is.7, i64 0, i64 0
	call void(ptr, i64)  @isort.3(ptr %t38, i64 6)
	%i.8 = alloca i64
	store i64 0, ptr %i.8
	br label %Cont1
Cont1:	%t39 = bitcast i8 0 to i8 ; NOP
	%t40 = load i64, ptr %i.8
	%t41 = icmp ult i64 %t40, 6
	%t42 = zext i1 %t41 to i8
	%t43 = icmp ne i8 %t42, 0
	br i1 %t43, label %Next1, label %Brk1
Next1:	%t44 = bitcast i8 0 to i8 ; NOP
	%x.9 = alloca i32
	%t46 = getelementptr [6 x i32], ptr %is.7, i32 0, i32 0
	%t47 = load i64, ptr %i.8
	%t48 = getelementptr i32, ptr %t46, i64 %t47
	%t45 = load i32, ptr %t48
	store i32 %t45, ptr %x.9
	%t49 = getelementptr [4 x i8], ptr @.str.3, i64 0, i64 0
	%t50 = load i32, ptr %x.9
	%t51 = call i32(ptr, ...)  @printf(ptr %t49, i32 %t50)
	%t52 = load i64, ptr %i.8
	%t53 = add i64 %t52, 1
	store i64 %t53, ptr %i.8
	br label %Cont1
Brk1:	%t54 = bitcast i8 0 to i8 ; NOP
	%i.10 = alloca i64
	store i64 0, ptr %i.10
	br label %Cont2
Cont2:	%t55 = bitcast i8 0 to i8 ; NOP
	%t56 = load i64, ptr %i.10
	%t57 = icmp ult i64 %t56, 6
	%t58 = zext i1 %t57 to i8
	%t59 = icmp ne i8 %t58, 0
	br i1 %t59, label %Next2, label %Brk2
Next2:	%t60 = bitcast i8 0 to i8 ; NOP
	%x.11 = alloca i32
	%t62 = getelementptr [6 x i32], ptr %is.7, i32 0, i32 0
	%t63 = load i64, ptr %i.10
	%t64 = getelementptr i32, ptr %t62, i64 %t63
	%t61 = load i32, ptr %t64
	store i32 %t61, ptr %x.11
	%t65 = getelementptr [4 x i8], ptr @.str.4, i64 0, i64 0
	%t66 = load i32, ptr %x.11
	%t67 = call i32(ptr, ...)  @printf(ptr %t65, i32 %t66)
	%t68 = load i64, ptr %i.10
	%t69 = add i64 %t68, 1
	store i64 %t69, ptr %i.10
	br label %Cont2
Brk2:	%t70 = bitcast i8 0 to i8 ; NOP
	%slice.12 = alloca { ptr, i64 }
	%t71 = sext i32 3 to i64
	%t72 = sext i32 5 to i64
	%t73 = sub i64 %t72, %t71
	%t74 = insertvalue { ptr, i64 } undef, ptr %is.7, 0
	%t75 = insertvalue { ptr, i64 } %t74, i64 %t73, 1
	store { ptr, i64 } %t75, ptr %slice.12
	%t76 = getelementptr [7 x i8], ptr @.str.5, i64 0, i64 0
	%t78 = load { ptr, i64 }, ptr %slice.12
	%t79 = extractvalue { ptr, i64 } %t78, 0
	%t80 = getelementptr i32, ptr %t79, i32 0
	%t77 = load i32, ptr %t80
	%t81 = call i32(ptr, ...)  @printf(ptr %t76, i32 %t77)
	%t82 = load { ptr, i64 }, ptr %slice.12
	%t83 = sext i32 1 to i64
	%t84 = sext i32 4 to i64
	%t85 = extractvalue { ptr, i64 } %t82, 0	%t86 = sub i64 %t84, %t83
	%t87 = insertvalue { ptr, i64 } undef, ptr %t85, 0
	%t88 = insertvalue { ptr, i64 } %t87, i64 %t86, 1
	store { ptr, i64 } %t88, ptr %slice.12
	%t89 = getelementptr [7 x i8], ptr @.str.6, i64 0, i64 0
	%t91 = load { ptr, i64 }, ptr %slice.12
	%t92 = extractvalue { ptr, i64 } %t91, 0
	%t93 = getelementptr i32, ptr %t92, i32 0
	%t90 = load i32, ptr %t93
	%t94 = call i32(ptr, ...)  @printf(ptr %t89, i32 %t90)
	%t95 = load { ptr, i64 }, ptr %slice.12
	%t96 = extractvalue { ptr, i64 } %t95, 1
	%v.13 = alloca { float, float }
	store { float, float } zeroinitializer, ptr %v.13
	%t97 = getelementptr [18 x i8], ptr @.str.7, i64 0, i64 0
	%t98 = call i32(ptr, ...)  @printf(ptr %t97, i64 24)
	%t99 = getelementptr [20 x i8], ptr @.str.8, i64 0, i64 0
	%t100 = call i32(ptr, ...)  @printf(ptr %t99, i64 8)
	%t101 = getelementptr [18 x i8], ptr @.str.9, i64 0, i64 0
	%t102 = call i32(ptr, ...)  @printf(ptr %t101, i64 8)
	%t103 = getelementptr [14 x i8], ptr @.str.10, i64 0, i64 0
	%t105 = alloca { float }
	store { float } zeroinitializer, ptr %t105
	%t106 = bitcast ptr %t105 to ptr
	store float 1.19999999999999995559108, ptr %t106
	%t107 = bitcast ptr %t105 to ptr	%t104 = load i32, ptr %t107
	%t108 = call i32(ptr, ...)  @printf(ptr %t103, i32 %t104)
	switch i64 6, label %ISx0 [ i64 0, label %IS0.0  i64 1, label %IS0.0  i64 3, label %IS0.1  ]
IS0.0: 	%t109 = icmp ult i64 6, 2
	%t110 = zext i1 %t109 to i8
	br label %ISe0
IS0.1: 	br label %ISe0
ISx0: 	br label %ISe0
ISe0: 	%t111 = bitcast i8 0 to i8 ; NOP
	%t113 = getelementptr [3 x i16], ptr %colors.2, i32 0, i32 0
	%t114 = getelementptr i16, ptr %t113, i32 0
	%t112 = load i16, ptr %t114
	switch i16 %t112, label %ISx0 [ i16 0, label %IS1.0  ]
IS1.0: 	br label %ISe1
ISx1: 	br label %ISe1
ISe1: 	%t115 = bitcast i8 0 to i8 ; NOP
	ret i32 0
	ret i32 undef
}
@.str.0 = internal constant [16 x i8] c"v = { %g, %g }\0A\00";
@.str.1 = internal constant [10 x i8] c"mag = %g\0A\00";
@.str.2 = internal constant [10 x i8] c"mag = %g\0A\00";
@.str.3 = internal constant [4 x i8] c"%d\0A\00";
@.str.4 = internal constant [4 x i8] c"%d\0A\00";
@.str.5 = internal constant [7 x i8] c"sl %d\0A\00";
@.str.6 = internal constant [7 x i8] c"sl %d\0A\00";
@.str.7 = internal constant [18 x i8] c"sizeof(is) = %zu\0A\00";
@.str.8 = internal constant [20 x i8] c"sizeof *void = %zu\0A\00";
@.str.9 = internal constant [18 x i8] c"alignof f64= %zu\0A\00";
@.str.10 = internal constant [14 x i8] c"1.2 -> %#.8x\0A\00";
declare float @sqrtf(float);
@stderr = external global ptr
declare i32 @printf(ptr, ...);
declare i64 @strlen(ptr);
@stdin = external global ptr
declare void @qsort(ptr, i64, i64, ptr);