clang-8 -c c.ll -O3 -target wasm32-unknown-musl

c.ll

; ModuleID = 'c'
source_filename = "c"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-musl"

%"[]u8.0" = type { i8*, i32 }
%builtin.StackTrace.1 = type { i32, %"[]usize.2" }
%"[]usize.2" = type { i32*, i32 }
%"std.math.frexp.frexp_result(f64)" = type { double, i32 }
%std.math.fma.dd = type { double, double }

@0 = internal unnamed_addr constant [24 x i8] c"reached unreachable code", align 1
@1 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([24 x i8], [24 x i8]* @0, i32 0, i32 0), i32 24 }, align 4
@2 = internal unnamed_addr constant [16 x i8] c"integer overflow", align 1
@3 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([16 x i8], [16 x i8]* @2, i32 0, i32 0), i32 16 }, align 4
@4 = internal unnamed_addr constant [29 x i8] c"TODO strerror implementation\00", align 1
@5 = internal unnamed_addr constant [23 x i8] c"stack smashing detected", align 1
@6 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([23 x i8], [23 x i8]* @5, i32 0, i32 0), i32 23 }, align 4
@7 = internal unnamed_addr constant double 1.000000e-300, align 8
@8 = internal unnamed_addr constant i32 -2147483648, align 4
@9 = internal unnamed_addr constant [27 x i8] c"integer cast truncated bits", align 1
@10 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([27 x i8], [27 x i8]* @9, i32 0, i32 0), i32 27 }, align 4
@11 = internal unnamed_addr constant [50 x i8] c"attempt to cast negative value to unsigned integer", align 1
@12 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([50 x i8], [50 x i8]* @11, i32 0, i32 0), i32 50 }, align 4
@13 = internal unnamed_addr constant float 0x39B4484C00000000, align 4
@14 = internal unnamed_addr constant i32 -2147483648, align 4
@15 = internal unnamed_addr constant [50 x i8] c"integer part of floating point value out of bounds", align 1
@16 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([50 x i8], [50 x i8]* @15, i32 0, i32 0), i32 50 }, align 4
@17 = internal unnamed_addr constant [2 x double] [double 5.000000e-01, double -5.000000e-01], align 8
@18 = internal unnamed_addr constant double 0x3FE62E42FEE00000, align 8
@19 = internal unnamed_addr constant double 0x3DEA39EF35793C76, align 8
@20 = internal unnamed_addr constant double 0x3FF71547652B82FE, align 8
@21 = internal unnamed_addr constant double 0x3FC555555555553E, align 8
@22 = internal unnamed_addr constant double 0xBF66C16C16BEBD93, align 8
@23 = internal unnamed_addr constant double 0x3F11566AAF25DE2C, align 8
@24 = internal unnamed_addr constant double 0xBEBBBD41C5D26BF1, align 8
@25 = internal unnamed_addr constant double 0x3E66376972BEA4D0, align 8
@26 = internal unnamed_addr constant [19 x i8] c"index out of bounds", align 1
@27 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @26, i32 0, i32 0), i32 19 }, align 4
@28 = internal unnamed_addr constant [2 x float] [float 5.000000e-01, float -5.000000e-01], align 4
@29 = internal unnamed_addr constant i32 256, align 4
@30 = internal unnamed_addr constant double 0x42B8000000000000, align 8
@31 = internal unnamed_addr constant double 0x3FE62E42FEFA39EF, align 8
@32 = internal unnamed_addr constant double 0x3FCEBFBDFF82C575, align 8
@33 = internal unnamed_addr constant double 0x3FAC6B08D704A0A6, align 8
@34 = internal unnamed_addr constant double 0x3F83B2AB88F70400, align 8
@35 = internal unnamed_addr constant double 0x3F55D88003875C74, align 8
@36 = internal unnamed_addr constant [16 x i8] c"division by zero", align 1
@37 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([16 x i8], [16 x i8]* @36, i32 0, i32 0), i32 16 }, align 4
@38 = internal unnamed_addr constant [44 x i8] c"remainder division by zero or negative value", align 1
@39 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([44 x i8], [44 x i8]* @38, i32 0, i32 0), i32 44 }, align 4
@40 = internal unnamed_addr constant i32 16, align 4
@41 = internal unnamed_addr constant float 7.864320e+05, align 4
@42 = internal unnamed_addr constant float 0x3FE62E4300000000, align 4
@43 = internal unnamed_addr constant float 0x3FCEBFBE00000000, align 4
@44 = internal unnamed_addr constant float 0x3FAC6B3480000000, align 4
@45 = internal unnamed_addr constant float 0x3F83B2C9C0000000, align 4
@46 = internal unnamed_addr constant double 0x3FE62E42FEE00000, align 8
@47 = internal unnamed_addr constant double 0x3DEA39EF35793C76, align 8
@48 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@49 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@50 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@51 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@52 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@53 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@54 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@55 = internal unnamed_addr constant float 0x3FE62E3000000000, align 4
@56 = internal unnamed_addr constant float 0x3EE2FEFA20000000, align 4
@57 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@58 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@59 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@60 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@61 = internal unnamed_addr constant double 0x3FF7154765200000, align 8
@62 = internal unnamed_addr constant double 0x3DE705FC2EEFA200, align 8
@63 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@64 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@65 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@66 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@67 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@68 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@69 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@70 = internal unnamed_addr constant float 0x3FF7160000000000, align 4
@71 = internal unnamed_addr constant float 0xBF27135A80000000, align 4
@72 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@73 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@74 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@75 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@76 = internal unnamed_addr constant double 0x3FDBCB7B15200000, align 8
@77 = internal unnamed_addr constant double 0x3DBB9438CA9AADD5, align 8
@78 = internal unnamed_addr constant double 0x3FD34413509F6000, align 8
@79 = internal unnamed_addr constant double 0x3D59FEF311F12B36, align 8
@80 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@81 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@82 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@83 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@84 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@85 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@86 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@87 = internal unnamed_addr constant float 0x3FDBCC0000000000, align 4
@88 = internal unnamed_addr constant float 0xBF009D5B20000000, align 4
@89 = internal unnamed_addr constant float 0x3FD3441000000000, align 4
@90 = internal unnamed_addr constant float 0x3EAA84FB60000000, align 4
@91 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@92 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@93 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@94 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@95 = internal unnamed_addr constant [30 x i8] c"cast causes pointer to be null", align 1
@96 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([30 x i8], [30 x i8]* @95, i32 0, i32 0), i32 30 }, align 4
@97 = internal unnamed_addr constant double 0x41A0000002000000, align 8

; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32) #3

; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32) #3

; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32) #3

; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1) #4

; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32) #3

; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #3

; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.ssub.with.overflow.i64(i64, i64) #3

; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32) #3

; Function Attrs: argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1) #4

; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.usub.with.overflow.i64(i64, i64) #3

; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.uadd.with.overflow.i64(i64, i64) #3

; Function Attrs: nobuiltin noreturn nounwind sspstrong
define internal fastcc void @panic(%"[]u8.0"* nonnull readonly align 4, %builtin.StackTrace.1* align 4) unnamed_addr #0 {
  unreachable
}

; Function Attrs: nobuiltin nounwind sspstrong
define double @fma(double, double, double) #1 {
Entry:
  %a = alloca double, align 8
  %b = alloca double, align 8
  %c = alloca double, align 8
  store double %0, double* %a, align 8
  store double %1, double* %b, align 8
  store double %2, double* %c, align 8
  %3 = load double, double* %a, align 8
  %4 = load double, double* %b, align 8
  %5 = load double, double* %c, align 8
  %6 = call fastcc double @std.math.fma.fma(double %3, double %4, double %5)
  ret double %6
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.fma(double, double, double) unnamed_addr #1 {
Entry:
  %x = alloca double, align 8
  %y = alloca double, align 8
  %z = alloca double, align 8
  store double %0, double* %x, align 8
  store double %1, double* %y, align 8
  store double %2, double* %z, align 8
  %3 = load double, double* %x, align 8
  %4 = load double, double* %y, align 8
  %5 = load double, double* %z, align 8
  %6 = call fastcc double @std.math.fma.fma64(double %3, double %4, double %5)
  ret double %6
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.fma64(double, double, double) unnamed_addr #1 {
Entry:
  %x1 = alloca %"std.math.frexp.frexp_result(f64)", align 8
  %ex = alloca i32, align 4
  %xs = alloca double, align 8
  %x2 = alloca %"std.math.frexp.frexp_result(f64)", align 8
  %ey = alloca i32, align 4
  %ys = alloca double, align 8
  %x3 = alloca %"std.math.frexp.frexp_result(f64)", align 8
  %ez = alloca i32, align 4
  %zs = alloca double, align 8
  %spread = alloca i32, align 4
  %xy = alloca %std.math.fma.dd, align 8
  %r = alloca %std.math.fma.dd, align 8
  %adj = alloca double, align 8
  %x = alloca double, align 8
  %y = alloca double, align 8
  %z = alloca double, align 8
  store double %0, double* %x, align 8
  store double %1, double* %y, align 8
  store double %2, double* %z, align 8
  %3 = load double, double* %x, align 8
  %4 = call fastcc i1 @std.math.isfinite.isFinite(double %3)
  %5 = icmp eq i1 %4, false
  br i1 %5, label %BoolOrTrue, label %BoolOrFalse

BoolOrFalse:                                      ; preds = %Entry
  %6 = load double, double* %y, align 8
  %7 = call fastcc i1 @std.math.isfinite.isFinite(double %6)
  %8 = icmp eq i1 %7, false
  br label %BoolOrTrue

BoolOrTrue:                                       ; preds = %BoolOrFalse, %Entry
  %9 = phi i1 [ %5, %Entry ], [ %8, %BoolOrFalse ]
  br i1 %9, label %Then, label %Else

Then:                                             ; preds = %BoolOrTrue
  %10 = load double, double* %x, align 8
  %11 = load double, double* %y, align 8
  %12 = fmul double %10, %11
  %13 = load double, double* %z, align 8
  %14 = fadd double %12, %13
  ret double %14

Else:                                             ; preds = %BoolOrTrue
  br label %EndIf

EndIf:                                            ; preds = %Else
  %15 = load double, double* %z, align 8
  %16 = call fastcc i1 @std.math.isfinite.isFinite(double %15)
  %17 = icmp eq i1 %16, false
  br i1 %17, label %Then1, label %Else2

Then1:                                            ; preds = %EndIf
  %18 = load double, double* %z, align 8
  ret double %18

Else2:                                            ; preds = %EndIf
  br label %EndIf3

EndIf3:                                           ; preds = %Else2
  %19 = load double, double* %x, align 8
  %20 = fcmp oeq double %19, 0.000000e+00
  br i1 %20, label %BoolOrTrue5, label %BoolOrFalse4

BoolOrFalse4:                                     ; preds = %EndIf3
  %21 = load double, double* %y, align 8
  %22 = fcmp oeq double %21, 0.000000e+00
  br label %BoolOrTrue5

BoolOrTrue5:                                      ; preds = %BoolOrFalse4, %EndIf3
  %23 = phi i1 [ %20, %EndIf3 ], [ %22, %BoolOrFalse4 ]
  br i1 %23, label %Then6, label %Else7

Then6:                                            ; preds = %BoolOrTrue5
  %24 = load double, double* %x, align 8
  %25 = load double, double* %y, align 8
  %26 = fmul double %24, %25
  %27 = load double, double* %z, align 8
  %28 = fadd double %26, %27
  ret double %28

Else7:                                            ; preds = %BoolOrTrue5
  br label %EndIf8

EndIf8:                                           ; preds = %Else7
  %29 = load double, double* %z, align 8
  %30 = fcmp oeq double %29, 0.000000e+00
  br i1 %30, label %Then9, label %Else10

Then9:                                            ; preds = %EndIf8
  %31 = load double, double* %x, align 8
  %32 = load double, double* %y, align 8
  %33 = fmul double %31, %32
  ret double %33

Else10:                                           ; preds = %EndIf8
  br label %EndIf11

EndIf11:                                          ; preds = %Else10
  %34 = load double, double* %x, align 8
  call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x1, double %34)
  %35 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x1, i32 0, i32 1
  %36 = load i32, i32* %35, align 4
  store i32 %36, i32* %ex, align 4
  %37 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x1, i32 0, i32 0
  %38 = load double, double* %37, align 8
  store double %38, double* %xs, align 8
  %39 = load double, double* %y, align 8
  call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x2, double %39)
  %40 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x2, i32 0, i32 1
  %41 = load i32, i32* %40, align 4
  store i32 %41, i32* %ey, align 4
  %42 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x2, i32 0, i32 0
  %43 = load double, double* %42, align 8
  store double %43, double* %ys, align 8
  %44 = load double, double* %z, align 8
  call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x3, double %44)
  %45 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x3, i32 0, i32 1
  %46 = load i32, i32* %45, align 4
  store i32 %46, i32* %ez, align 4
  %47 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x3, i32 0, i32 0
  %48 = load double, double* %47, align 8
  store double %48, double* %zs, align 8
  %49 = load i32, i32* %ex, align 4
  %50 = load i32, i32* %ey, align 4
  %51 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %49, i32 %50)
  %52 = extractvalue { i32, i1 } %51, 0
  %53 = extractvalue { i32, i1 } %51, 1
  br i1 %53, label %OverflowFail, label %OverflowOk

Then12:                                           ; preds = %OverflowOk21
  %54 = load double, double* %zs, align 8
  %55 = load i32, i32* %spread, align 4
  %56 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 0, i32 %55)
  %57 = extractvalue { i32, i1 } %56, 0
  %58 = extractvalue { i32, i1 } %56, 1
  br i1 %58, label %OverflowFail22, label %OverflowOk23

Else13:                                           ; preds = %OverflowOk21
  %59 = load double, double* %zs, align 8
  %60 = call fastcc double @std.math.copysign.copysign(double 0x10000000000000, double %59)
  store double %60, double* %zs, align 8
  br label %EndIf14

EndIf14:                                          ; preds = %Else13, %OverflowOk23
  %61 = load double, double* %xs, align 8
  %62 = load double, double* %ys, align 8
  %63 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 0
  %64 = load double, double* %63, align 8
  %65 = load double, double* %zs, align 8
  %66 = load i32, i32* %ex, align 4
  %67 = load i32, i32* %ey, align 4
  %68 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %66, i32 %67)
  %69 = extractvalue { i32, i1 } %68, 0
  %70 = extractvalue { i32, i1 } %68, 1
  br i1 %70, label %OverflowFail24, label %OverflowOk25

Then15:                                           ; preds = %OverflowOk25
  %71 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 0
  %72 = load double, double* %71, align 8
  %73 = load double, double* %zs, align 8
  %74 = fadd double %72, %73
  %75 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 1
  %76 = load double, double* %75, align 8
  %77 = load i32, i32* %spread, align 4
  %78 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
  %79 = fadd double %74, %78
  ret double %79

Else16:                                           ; preds = %OverflowOk25
  br label %EndIf17

EndIf17:                                          ; preds = %Else16
  %80 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 1
  %81 = load double, double* %80, align 8
  %82 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 1
  %83 = load double, double* %82, align 8
  %84 = call fastcc double @std.math.fma.add_adjusted(double %81, double %83)
  store double %84, double* %adj, align 8
  %85 = load i32, i32* %spread, align 4
  %86 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
  %87 = load double, double* %86, align 8
  %88 = add i32 0, 0
  %89 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %85, i32 %88)
  %90 = extractvalue { i32, i1 } %89, 0
  %91 = extractvalue { i32, i1 } %89, 1
  br i1 %91, label %OverflowFail26, label %OverflowOk27

Then18:                                           ; preds = %OverflowOk27
  %92 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
  %93 = load double, double* %92, align 8
  %94 = load double, double* %adj, align 8
  %95 = fadd double %93, %94
  %96 = load i32, i32* %spread, align 4
  %97 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
  ret double %97

Else19:                                           ; preds = %OverflowOk27
  %98 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
  %99 = load double, double* %98, align 8
  %100 = load double, double* %adj, align 8
  %101 = load i32, i32* %spread, align 4
  %102 = call fastcc double @std.math.fma.add_and_denorm(double %99, double %100, i32 %101)
  ret double %102

OverflowFail:                                     ; preds = %EndIf11
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk:                                       ; preds = %EndIf11
  %103 = load i32, i32* %ez, align 4
  %104 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %52, i32 %103)
  %105 = extractvalue { i32, i1 } %104, 0
  %106 = extractvalue { i32, i1 } %104, 1
  br i1 %106, label %OverflowFail20, label %OverflowOk21

OverflowFail20:                                   ; preds = %OverflowOk
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk21:                                     ; preds = %OverflowOk
  store i32 %105, i32* %spread, align 4
  %107 = load i32, i32* %spread, align 4
  %108 = icmp sle i32 %107, 106
  br i1 %108, label %Then12, label %Else13

OverflowFail22:                                   ; preds = %Then12
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk23:                                     ; preds = %Then12
  %109 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
  store double %109, double* %zs, align 8
  br label %EndIf14

OverflowFail24:                                   ; preds = %EndIf14
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk25:                                     ; preds = %EndIf14
  store i32 %69, i32* %spread, align 4
  %110 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
  %111 = load double, double* %110, align 8
  %112 = fcmp oeq double %111, 0.000000e+00
  br i1 %112, label %Then15, label %Else16

OverflowFail26:                                   ; preds = %EndIf17
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk27:                                     ; preds = %EndIf17
  %113 = icmp sgt i32 %90, -1023
  br i1 %113, label %Then18, label %Else19
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.copysign.copysign(double, double) unnamed_addr #1 {
Entry:
  %x = alloca double, align 8
  %y = alloca double, align 8
  store double %0, double* %x, align 8
  store double %1, double* %y, align 8
  %2 = load double, double* %x, align 8
  %3 = load double, double* %y, align 8
  %4 = call fastcc double @std.math.copysign.copysign64(double %2, double %3)
  ret double %4
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.copysign.copysign64(double, double) unnamed_addr #1 {
Entry:
  %ux = alloca i64, align 8
  %uy = alloca i64, align 8
  %h1 = alloca i64, align 8
  %h2 = alloca i64, align 8
  %x = alloca double, align 8
  %y = alloca double, align 8
  store double %0, double* %x, align 8
  store double %1, double* %y, align 8
  %2 = load double, double* %x, align 8
  %3 = bitcast i64* %ux to double*
  store double %2, double* %3, align 8
  %4 = load double, double* %y, align 8
  %5 = bitcast i64* %uy to double*
  store double %4, double* %5, align 8
  %6 = load i64, i64* %ux, align 8
  %7 = and i64 %6, 9223372036854775807
  store i64 %7, i64* %h1, align 8
  %8 = load i64, i64* %uy, align 8
  %9 = and i64 %8, -9223372036854775808
  store i64 %9, i64* %h2, align 8
  %10 = load i64, i64* %h1, align 8
  %11 = load i64, i64* %h2, align 8
  %12 = or i64 %10, %11
  %13 = bitcast i64 %12 to double
  ret double %13
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.add_adjusted(double, double) unnamed_addr #1 {
Entry:
  %sum = alloca %std.math.fma.dd, align 8
  %uhii = alloca i64, align 8
  %uloi = alloca i64, align 8
  %a = alloca double, align 8
  %b = alloca double, align 8
  store double %0, double* %a, align 8
  store double %1, double* %b, align 8
  %2 = load double, double* %a, align 8
  %3 = load double, double* %b, align 8
  %4 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
  %5 = load double, double* %4, align 8
  %6 = fcmp une double %5, 0.000000e+00
  br i1 %6, label %Then, label %Else2

Then:                                             ; preds = %Entry
  %7 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %8 = load double, double* %7, align 8
  %9 = bitcast i64* %uhii to double*
  store double %8, double* %9, align 8
  %10 = load i64, i64* %uhii, align 8
  %11 = and i64 %10, 1
  %12 = icmp eq i64 %11, 0
  br i1 %12, label %Then1, label %Else

Then1:                                            ; preds = %Then
  %13 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
  %14 = load double, double* %13, align 8
  %15 = bitcast i64* %uloi to double*
  store double %14, double* %15, align 8
  %16 = load i64, i64* %uhii, align 8
  %17 = load i64, i64* %uhii, align 8
  %18 = load i64, i64* %uloi, align 8
  %19 = xor i64 %17, %18
  %20 = lshr i64 %19, 62
  %21 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 1, i64 %20)
  %22 = extractvalue { i64, i1 } %21, 0
  %23 = extractvalue { i64, i1 } %21, 1
  br i1 %23, label %OverflowFail, label %OverflowOk

Else:                                             ; preds = %Then
  br label %EndIf

EndIf:                                            ; preds = %Else, %OverflowOk5
  br label %EndIf3

Else2:                                            ; preds = %Entry
  br label %EndIf3

EndIf3:                                           ; preds = %Else2, %EndIf
  %24 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %25 = load double, double* %24, align 8
  ret double %25

OverflowFail:                                     ; preds = %Then1
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk:                                       ; preds = %Then1
  %26 = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %16, i64 %22)
  %27 = extractvalue { i64, i1 } %26, 0
  %28 = extractvalue { i64, i1 } %26, 1
  br i1 %28, label %OverflowFail4, label %OverflowOk5

OverflowFail4:                                    ; preds = %OverflowOk
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk5:                                      ; preds = %OverflowOk
  store i64 %27, i64* %uhii, align 8
  %29 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %30 = load i64, i64* %uhii, align 8
  %31 = bitcast i64 %30 to double
  store double %31, double* %29, align 8
  br label %EndIf
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.add_and_denorm(double, double, i32) unnamed_addr #1 {
Entry:
  %sum = alloca %std.math.fma.dd, align 8
  %uhii = alloca i64, align 8
  %bits_lost = alloca i32, align 4
  %uloi = alloca i64, align 8
  %a = alloca double, align 8
  %b = alloca double, align 8
  %scale = alloca i32, align 4
  store double %0, double* %a, align 8
  store double %1, double* %b, align 8
  store i32 %2, i32* %scale, align 4
  %3 = load double, double* %a, align 8
  %4 = load double, double* %b, align 8
  %5 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
  %6 = load double, double* %5, align 8
  %7 = fcmp une double %6, 0.000000e+00
  br i1 %7, label %Then, label %Else2

Then:                                             ; preds = %Entry
  %8 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %9 = load double, double* %8, align 8
  %10 = bitcast i64* %uhii to double*
  store double %9, double* %10, align 8
  %11 = load i64, i64* %uhii, align 8
  %12 = lshr i64 %11, 52
  %13 = and i64 %12, 2047
  %14 = trunc i64 %13 to i32
  %15 = sext i32 %14 to i64
  %16 = icmp eq i64 %13, %15
  br i1 %16, label %CastShortenOk, label %CastShortenFail

Then1:                                            ; preds = %OverflowOk7
  %17 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
  %18 = load double, double* %17, align 8
  %19 = bitcast i64* %uloi to double*
  store double %18, double* %19, align 8
  %20 = load i64, i64* %uhii, align 8
  %21 = load i64, i64* %uhii, align 8
  %22 = load i64, i64* %uloi, align 8
  %23 = xor i64 %21, %22
  %24 = lshr i64 %23, 62
  %25 = and i64 %24, 2
  %26 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 1, i64 %25)
  %27 = extractvalue { i64, i1 } %26, 0
  %28 = extractvalue { i64, i1 } %26, 1
  br i1 %28, label %OverflowFail8, label %OverflowOk9

Else:                                             ; preds = %OverflowOk7
  br label %EndIf

EndIf:                                            ; preds = %Else, %OverflowOk11
  br label %EndIf3

Else2:                                            ; preds = %Entry
  br label %EndIf3

EndIf3:                                           ; preds = %Else2, %EndIf
  %29 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %30 = load double, double* %29, align 8
  %31 = load i32, i32* %scale, align 4
  %32 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
  ret double %32

CastShortenOk:                                    ; preds = %Then
  %33 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 0, i32 %14)
  %34 = extractvalue { i32, i1 } %33, 0
  %35 = extractvalue { i32, i1 } %33, 1
  br i1 %35, label %OverflowFail, label %OverflowOk

CastShortenFail:                                  ; preds = %Then
  tail call fastcc void @panic(%"[]u8.0"* @10, %builtin.StackTrace.1* null)
  unreachable

OverflowFail:                                     ; preds = %CastShortenOk
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk:                                       ; preds = %CastShortenOk
  %36 = load i32, i32* %scale, align 4
  %37 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %34, i32 %36)
  %38 = extractvalue { i32, i1 } %37, 0
  %39 = extractvalue { i32, i1 } %37, 1
  br i1 %39, label %OverflowFail4, label %OverflowOk5

OverflowFail4:                                    ; preds = %OverflowOk
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk5:                                      ; preds = %OverflowOk
  %40 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %38, i32 1)
  %41 = extractvalue { i32, i1 } %40, 0
  %42 = extractvalue { i32, i1 } %40, 1
  br i1 %42, label %OverflowFail6, label %OverflowOk7

OverflowFail6:                                    ; preds = %OverflowOk5
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk7:                                      ; preds = %OverflowOk5
  store i32 %41, i32* %bits_lost, align 4
  %43 = load i32, i32* %bits_lost, align 4
  %44 = icmp ne i32 %43, 1
  %45 = load i64, i64* %uhii, align 8
  %46 = and i64 %45, 1
  %47 = icmp ne i64 %46, 0
  %48 = icmp eq i1 %44, %47
  br i1 %48, label %Then1, label %Else

OverflowFail8:                                    ; preds = %Then1
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk9:                                      ; preds = %Then1
  %49 = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %20, i64 %27)
  %50 = extractvalue { i64, i1 } %49, 0
  %51 = extractvalue { i64, i1 } %49, 1
  br i1 %51, label %OverflowFail10, label %OverflowOk11

OverflowFail10:                                   ; preds = %OverflowOk9
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk11:                                     ; preds = %OverflowOk9
  store i64 %50, i64* %uhii, align 8
  %52 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
  %53 = load i64, i64* %uhii, align 8
  %54 = bitcast i64 %53 to double
  store double %54, double* %52, align 8
  br label %EndIf
}

define internal fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* nonnull sret, double) unnamed_addr #1 {
Entry:
  %x = alloca double, align 8
  store double %1, double* %x, align 8
  %2 = load double, double* %x, align 8
  call fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* sret %0, double %2)
  ret void
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* nonnull sret, double) unnamed_addr #1 {
Entry:
  %result = alloca %"std.math.frexp.frexp_result(f64)", align 8
  %y = alloca i64, align 8
  %e = alloca i32, align 4
  %2 = alloca %"std.math.frexp.frexp_result(f64)", align 8
  %x = alloca double, align 8
  store double %1, double* %x, align 8
  %3 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
  call void @llvm.memset.p0i8.i32(i8* align 8 %3, i8 -86, i32 16, i1 false)
  %4 = load double, double* %x, align 8
  %5 = bitcast i64* %y to double*
  store double %4, double* %5, align 8
  %6 = load i64, i64* %y, align 8
  %7 = lshr i64 %6, 52
  %8 = trunc i64 %7 to i32
  %9 = sext i32 %8 to i64
  %10 = icmp eq i64 %7, %9
  br i1 %10, label %CastShortenOk, label %CastShortenFail

Then:                                             ; preds = %CastShortenOk
  %11 = load double, double* %x, align 8
  %12 = fcmp une double %11, 0.000000e+00
  br i1 %12, label %Then1, label %Else

Then1:                                            ; preds = %Then
  %13 = load double, double* %x, align 8
  %14 = fmul double %13, 0x43F0000000000000
  call fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* sret %2, double %14)
  %15 = bitcast %"std.math.frexp.frexp_result(f64)"* %2 to i8*
  %16 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %16, i8* align 8 %15, i32 16, i1 false)
  %17 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
  %18 = load i32, i32* %17, align 4
  %19 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %18, i32 64)
  %20 = extractvalue { i32, i1 } %19, 0
  %21 = extractvalue { i32, i1 } %19, 1
  br i1 %21, label %OverflowFail, label %OverflowOk

Else:                                             ; preds = %Then
  %22 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
  %23 = load double, double* %x, align 8
  store double %23, double* %22, align 8
  %24 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
  store i32 0, i32* %24, align 4
  br label %EndIf

EndIf:                                            ; preds = %Else, %OverflowOk
  %25 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
  %26 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %26, i8* align 8 %25, i32 16, i1 false)
  ret void

Else2:                                            ; preds = %CastShortenOk
  %27 = load i32, i32* %e, align 4
  %28 = icmp eq i32 %27, 2047
  br i1 %28, label %Then3, label %Else7

Then3:                                            ; preds = %Else2
  %29 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
  %30 = load double, double* %x, align 8
  store double %30, double* %29, align 8
  %31 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
  %32 = bitcast i32* %31 to i8*
  call void @llvm.memset.p0i8.i32(i8* align 4 %32, i8 -86, i32 4, i1 false)
  %33 = load double, double* %x, align 8
  %34 = add i1 0, 0
  br i1 %34, label %Then4, label %Else5

Then4:                                            ; preds = %Then3
  %35 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
  store i32 0, i32* %35, align 4
  br label %EndIf6

Else5:                                            ; preds = %Then3
  br label %EndIf6

EndIf6:                                           ; preds = %Else5, %Then4
  %36 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
  %37 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %37, i8* align 8 %36, i32 16, i1 false)
  ret void

Else7:                                            ; preds = %Else2
  br label %EndIf8

EndIf8:                                           ; preds = %Else7
  br label %EndIf9

EndIf9:                                           ; preds = %EndIf8
  %38 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
  %39 = load i32, i32* %e, align 4
  %40 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %39, i32 1022)
  %41 = extractvalue { i32, i1 } %40, 0
  %42 = extractvalue { i32, i1 } %40, 1
  br i1 %42, label %OverflowFail10, label %OverflowOk11

CastShortenOk:                                    ; preds = %Entry
  %43 = and i32 %8, 2047
  store i32 %43, i32* %e, align 4
  %44 = load i32, i32* %e, align 4
  %45 = icmp eq i32 %44, 0
  br i1 %45, label %Then, label %Else2

CastShortenFail:                                  ; preds = %Entry
  tail call fastcc void @panic(%"[]u8.0"* @10, %builtin.StackTrace.1* null)
  unreachable

OverflowFail:                                     ; preds = %Then1
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk:                                       ; preds = %Then1
  store i32 %20, i32* %17, align 4
  br label %EndIf

OverflowFail10:                                   ; preds = %EndIf9
  tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
  unreachable

OverflowOk11:                                     ; preds = %EndIf9
  store i32 %41, i32* %38, align 4
  %46 = load i64, i64* %y, align 8
  %47 = and i64 %46, -9218868437227405313
  store i64 %47, i64* %y, align 8
  %48 = load i64, i64* %y, align 8
  %49 = or i64 %48, 4602678819172646912
  store i64 %49, i64* %y, align 8
  %50 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
  %51 = load i64, i64* %y, align 8
  %52 = bitcast i64 %51 to double
  store double %52, double* %50, align 8
  %53 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
  %54 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %54, i8* align 8 %53, i32 16, i1 false)
  ret void
}

; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc i1 @std.math.isfinite.isFinite(double) unnamed_addr #1 {
Entry:
  %bits = alloca i64, align 8
  %x = alloca double, align 8
  store double %0, double* %x, align 8
  %1 = load double, double* %x, align 8
  %2 = bitcast i64* %bits to double*
  store double %1, double* %2, align 8
  %3 = load i64, i64* %bits, align 8
  %4 = and i64 %3, 9223372036854775807
  %5 = icmp ult i64 %4, 9218868437227405312
  ret i1 %5
}

attributes #0 = { nobuiltin noreturn nounwind sspstrong "stack-protector-buffer-size"="4" }
attributes #1 = { nobuiltin nounwind sspstrong "stack-protector-buffer-size"="4" }
attributes #2 = { nobuiltin nounwind }
attributes #3 = { nounwind readnone speculatable }
attributes #4 = { argmemonly nounwind }