# math
..\..\..\..\math\unsafe.go:17:6: can inline Float64bits as: func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\unsafe.go:21:6: can inline Float64frombits as: func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\abs.go:12:6: can inline Abs as: func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\abs.go:13:36: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\abs.go:13:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\acosh.go:42:6: cannot inline Acosh: no function body
..\..\..\..\math\bits.go:34:6: can inline IsNaN as: func(float64) bool { return f != f }
..\..\..\..\math\bits.go:31:6: can inline NaN as: func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\bits.go:31:44: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log.go:80:6: cannot inline Log: no function body
..\..\..\..\math\sqrt.go:92:6: cannot inline Sqrt: no function body
..\..\..\..\math\log1p.go:95:6: cannot inline Log1p: no function body
..\..\..\..\math\acosh.go:44:6: cannot inline acosh: non-leaf function
..\..\..\..\math\acosh.go:51:21: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\acosh.go:52:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\acosh.go:52:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\asin.go:19:6: cannot inline Asin: no function body
..\..\..\..\math\atan.go:55:6: can inline xatan as: func(float64) float64 { <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; z := x * x; z = z * ((((P0 * z + P1) * z + P2) * z + P3) * z + P4) / (((((z + Q0) * z + Q1) * z + Q2) * z + Q3) * z + Q4); z = x * z + x; return z }
..\..\..\..\math\atan.go:76:6: cannot inline satan: function too complex: cost 207 exceeds budget 80
..\..\..\..\math\atan.go:82:15: inlining call to xatan func(float64) float64 { <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; z := x * x; z = z * ((((P0 * z + P1) * z + P2) * z + P3) * z + P4) / (((((z + Q0) * z + Q1) * z + Q2) * z + Q3) * z + Q4); z = x * z + x; return z }
..\..\..\..\math\atan.go:85:22: inlining call to xatan func(float64) float64 { <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; z := x * x; z = z * ((((P0 * z + P1) * z + P2) * z + P3) * z + P4) / (((((z + Q0) * z + Q1) * z + Q2) * z + Q3) * z + Q4); z = x * z + x; return z }
..\..\..\..\math\atan.go:87:21: inlining call to xatan func(float64) float64 { <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; <node DCLCONST>; z := x * x; z = z * ((((P0 * z + P1) * z + P2) * z + P3) * z + P4) / (((((z + Q0) * z + Q1) * z + Q2) * z + Q3) * z + Q4); z = x * z + x; return z }
..\..\..\..\math\asin.go:21:6: cannot inline asin: non-leaf function
..\..\..\..\math\asin.go:31:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\asin.go:31:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\asin.go:51:6: cannot inline Acos: no function body
..\..\..\..\math\asin.go:53:6: cannot inline acos: non-leaf function
..\..\..\..\math\asinh.go:39:6: cannot inline Asinh: no function body
..\..\..\..\math\bits.go:46:6: can inline IsInf as: func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\asinh.go:41:6: cannot inline asinh: non-leaf function
..\..\..\..\math\asinh.go:48:10: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\asinh.go:48:22: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan.go:95:6: cannot inline Atan: no function body
..\..\..\..\math\atan.go:97:6: cannot inline atan: non-leaf function
..\..\..\..\math\atan2.go:29:6: cannot inline Atan2: no function body
..\..\..\..\math\signbit.go:8:6: can inline Signbit as: func(float64) bool { return Float64bits(x) & (1 << 63) != 0 }
..\..\..\..\math\signbit.go:9:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\copysign.go:9:6: can inline Copysign as: func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\copysign.go:11:36: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\copysign.go:11:59: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\copysign.go:11:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:31:6: cannot inline atan2: non-leaf function
..\..\..\..\math\atan2.go:34:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\atan2.go:34:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\atan2.go:35:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\atan2.go:35:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:37:24: inlining call to Signbit func(float64) bool { return Float64bits(x) & (1 << 63) != 0 }
..\..\..\..\math\atan2.go:37:24: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:38:19: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:38:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:38:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:38:19: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:40:18: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:40:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:40:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:40:18: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:42:18: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:42:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:42:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:42:18: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:43:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan2.go:44:11: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan2.go:46:14: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan2.go:47:20: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:47:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:47:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:47:20: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:49:20: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:49:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:49:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:49:20: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:53:13: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan2.go:54:19: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:54:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:54:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:54:19: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:56:19: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:56:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:56:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:56:19: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atan2.go:58:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\atan2.go:59:18: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\atan2.go:59:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:59:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\atan2.go:59:18: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atanh.go:47:6: cannot inline Atanh: no function body
..\..\..\..\math\bits.go:20:6: can inline Inf as: func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\bits.go:27:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atanh.go:49:6: cannot inline atanh: non-leaf function
..\..\..\..\math\atanh.go:53:31: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\atanh.go:54:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\atanh.go:54:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atanh.go:56:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\atanh.go:56:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\atanh.go:58:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\atanh.go:58:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\bits.go:56:6: can inline normalize as: func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\bits.go:58:8: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\bits.go:58:8: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\bits.go:58:8: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\cbrt.go:25:6: cannot inline Cbrt: no function body
..\..\..\..\math\cbrt.go:27:6: cannot inline cbrt: function too complex: cost 206 exceeds budget 80
..\..\..\..\math\cbrt.go:40:22: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\cbrt.go:40:34: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\cbrt.go:51:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\cbrt.go:51:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\cbrt.go:56:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\cbrt.go:56:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\cbrt.go:65:33: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\cbrt.go:65:21: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\dim.go:13:6: can inline Dim as: func(float64, float64) float64 { v := x - y; if v <= 0 { return 0 }; return v }
..\..\..\..\math\dim.go:35:6: cannot inline Max: no function body
..\..\..\..\math\dim.go:37:6: cannot inline max: function too complex: cost 138 exceeds budget 80
..\..\..\..\math\dim.go:40:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\dim.go:40:27: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\dim.go:41:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\dim.go:41:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\dim.go:42:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\dim.go:42:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\dim.go:43:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\dim.go:43:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\dim.go:45:13: inlining call to Signbit func(float64) bool { return Float64bits(x) & (1 << 63) != 0 }
..\..\..\..\math\dim.go:45:13: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\dim.go:62:6: cannot inline Min: no function body
..\..\..\..\math\dim.go:64:6: cannot inline min: function too complex: cost 138 exceeds budget 80
..\..\..\..\math\dim.go:67:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\dim.go:67:28: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\dim.go:68:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\dim.go:68:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\dim.go:69:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\dim.go:69:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\dim.go:70:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\dim.go:70:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\dim.go:72:13: inlining call to Signbit func(float64) bool { return Float64bits(x) & (1 << 63) != 0 }
..\..\..\..\math\dim.go:72:13: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\erf.go:188:6: cannot inline Erf: no function body
..\..\..\..\math\exp.go:14:6: cannot inline Exp: no function body
..\..\..\..\math\erf.go:190:6: cannot inline erf: non-leaf function
..\..\..\..\math\erf.go:197:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\erf.go:198:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\erf.go:198:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erf.go:199:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\erf.go:201:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\erf.go:253:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\erf.go:253:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erf.go:267:6: cannot inline Erfc: no function body
..\..\..\..\math\erf.go:269:6: cannot inline erfc: non-leaf function
..\..\..\..\math\erf.go:273:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\erf.go:274:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\erf.go:274:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erf.go:275:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\erf.go:277:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\erf.go:328:35: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\erf.go:328:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erfinv.go:76:6: cannot inline Erfinv: non-leaf function
..\..\..\..\math\erfinv.go:78:10: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\erfinv.go:80:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\erfinv.go:80:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erfinv.go:82:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\erfinv.go:82:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\erfinv.go:125:6: cannot inline Erfcinv: non-leaf function
..\..\..\..\math\ldexp.go:14:6: cannot inline Ldexp: no function body
..\..\..\..\math\exp.go:176:6: cannot inline expmulti: non-leaf function
..\..\..\..\math\exp.go:92:6: cannot inline exp: non-leaf function
..\..\..\..\math\exp.go:105:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\exp.go:105:24: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\exp.go:107:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\exp.go:110:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\exp.go:110:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\exp.go:135:6: cannot inline Exp2: no function body
..\..\..\..\math\exp.go:137:6: cannot inline exp2: non-leaf function
..\..\..\..\math\exp.go:148:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\exp.go:148:24: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\exp.go:150:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\exp.go:153:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\exp.go:153:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:124:6: cannot inline Expm1: no function body
..\..\..\..\math\expm1.go:126:6: cannot inline expm1: function too complex: cost 503 exceeds budget 80
..\..\..\..\math\expm1.go:146:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\expm1.go:146:27: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\expm1.go:148:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\expm1.go:165:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\expm1.go:165:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:223:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\expm1.go:223:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:227:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:229:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\expm1.go:229:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:232:21: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\expm1.go:235:33: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\expm1.go:235:21: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\floor.go:13:6: cannot inline Floor: no function body
..\..\..\..\math\modf.go:13:6: cannot inline Modf: no function body
..\..\..\..\math\floor.go:15:6: cannot inline floor: non-leaf function
..\..\..\..\math\floor.go:16:20: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\floor.go:16:32: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\floor.go:36:6: cannot inline Ceil: no function body
..\..\..\..\math\floor.go:38:6: can inline ceil as: func(float64) float64 { return -Floor(-x) }
..\..\..\..\math\floor.go:48:6: cannot inline Trunc: no function body
..\..\..\..\math\floor.go:50:6: cannot inline trunc: non-leaf function
..\..\..\..\math\floor.go:51:20: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\floor.go:51:32: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\floor.go:64:6: can inline Round as: func(float64) float64 { bits := Float64bits(x); e := uint(bits >> shift) & mask; if e < bias { bits &= signMask; if e == bias - 1 { bits |= uvone } } else { if e < bias + shift { <node DCLCONST>; e -= bias; bits += half >> e; bits &^= fracMask >> e } }; return Float64frombits(bits) }
..\..\..\..\math\floor.go:74:21: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\floor.go:92:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\floor.go:101:6: can inline RoundToEven as: func(float64) float64 { bits := Float64bits(x); e := uint(bits >> shift) & mask; if e >= bias { <node DCLCONST>; e -= bias; bits += (halfMinusULP + bits >> (shift - e) & 1) >> e; bits &^= fracMask >> e } else { if e == bias - 1 && bits & fracMask != 0 { bits = bits & signMask | uvone } else { bits &= signMask } }; return Float64frombits(bits) }
..\..\..\..\math\floor.go:112:21: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\floor.go:130:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\frexp.go:16:6: cannot inline Frexp: no function body
..\..\..\..\math\frexp.go:18:6: cannot inline frexp: function too complex: cost 123 exceeds budget 80
..\..\..\..\math\frexp.go:23:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\frexp.go:23:27: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\frexp.go:26:20: inlining call to normalize func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\frexp.go:26:20: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\frexp.go:26:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\frexp.go:26:20: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\frexp.go:27:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\frexp.go:31:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:38:6: cannot inline Pow: no function body
..\..\..\..\math\gamma.go:100:6: cannot inline stirling: non-leaf function
..\..\..\..\math\gamma.go:102:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:102:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:215:6: cannot inline isNegInt: non-leaf function
..\..\..\..\math\sin.go:174:6: cannot inline Sin: no function body
..\..\..\..\math\gamma.go:130:6: cannot inline Gamma: non-leaf function
..\..\..\..\math\gamma.go:134:27: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\gamma.go:134:43: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\gamma.go:135:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\gamma.go:135:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:136:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\gamma.go:137:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:137:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:139:13: inlining call to Signbit func(float64) bool { return Float64bits(x) & (1 << 63) != 0 }
..\..\..\..\math\gamma.go:139:13: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\gamma.go:140:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:140:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:142:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:142:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:144:10: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\gamma.go:144:10: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\gamma.go:144:10: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:165:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:165:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:168:14: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\gamma.go:168:14: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\gamma.go:168:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\gamma.go:170:11: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\gamma.go:210:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\gamma.go:210:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\hypot.go:19:6: cannot inline Hypot: no function body
..\..\..\..\math\hypot.go:21:6: cannot inline hypot: function too complex: cost 147 exceeds budget 80
..\..\..\..\math\hypot.go:24:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\hypot.go:24:27: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\hypot.go:25:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\hypot.go:25:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\hypot.go:26:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\hypot.go:26:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\hypot.go:27:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\hypot.go:27:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sincos.go:17:6: cannot inline Sincos: function too complex: cost 269 exceeds budget 80
..\..\..\..\math\sincos.go:28:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\sincos.go:28:24: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\sincos.go:29:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\sincos.go:29:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sincos.go:29:20: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\sincos.go:29:20: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sin.go:117:6: cannot inline Cos: no function body
..\..\..\..\math\j0.go:307:6: cannot inline pzero: function too complex: cost 154 exceeds budget 80
..\..\..\..\math\j0.go:410:6: cannot inline qzero: function too complex: cost 163 exceeds budget 80
..\..\..\..\math\j0.go:76:6: cannot inline J0: non-leaf function
..\..\..\..\math\j0.go:94:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\j0.go:96:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\j0.go:156:6: cannot inline Y0: non-leaf function
..\..\..\..\math\j0.go:174:21: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\j0.go:175:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\j0.go:175:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\j0.go:176:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\j0.go:179:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\j0.go:179:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\j1.go:300:6: cannot inline pone: function too complex: cost 154 exceeds budget 80
..\..\..\..\math\j1.go:403:6: cannot inline qone: function too complex: cost 163 exceeds budget 80
..\..\..\..\math\j1.go:74:6: cannot inline J1: non-leaf function
..\..\..\..\math\j1.go:91:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\j1.go:93:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\j1.go:154:6: cannot inline Y1: non-leaf function
..\..\..\..\math\j1.go:171:21: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\j1.go:172:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\j1.go:172:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\j1.go:173:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\j1.go:176:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\j1.go:176:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\jn.go:53:6: cannot inline Jn: non-leaf function
..\..\..\..\math\jn.go:60:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\jn.go:62:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\jn.go:198:23: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\jn.go:198:23: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\jn.go:198:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\jn.go:233:6: cannot inline Yn: non-leaf function
..\..\..\..\math\jn.go:237:21: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\jn.go:238:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\jn.go:238:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\jn.go:239:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\jn.go:248:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\jn.go:248:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\jn.go:250:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\jn.go:250:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\jn.go:296:30: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\ldexp.go:16:6: cannot inline ldexp: function too complex: cost 249 exceeds budget 80
..\..\..\..\math\ldexp.go:21:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\ldexp.go:21:30: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\ldexp.go:24:22: inlining call to normalize func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\ldexp.go:24:22: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\ldexp.go:24:22: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\ldexp.go:24:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\ldexp.go:26:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\ldexp.go:29:18: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\ldexp.go:29:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\ldexp.go:29:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\ldexp.go:29:18: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\ldexp.go:33:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\ldexp.go:33:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\ldexp.go:35:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\ldexp.go:35:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\ldexp.go:44:28: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\mod.go:21:6: cannot inline Mod: no function body
..\..\..\..\math\lgamma.go:324:6: cannot inline sinPi: non-leaf function
..\..\..\..\math\lgamma.go:347:27: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\lgamma.go:174:6: cannot inline Lgamma: non-leaf function
..\..\..\..\math\lgamma.go:189:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\lgamma.go:192:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\lgamma.go:196:15: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\lgamma.go:196:15: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\lgamma.go:216:16: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\lgamma.go:216:16: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\lgamma.go:221:16: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\lgamma.go:221:16: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\lgamma.go:224:22: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\lgamma.go:224:22: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\lgamma.go:224:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log.go:82:6: cannot inline log: non-leaf function
..\..\..\..\math\log.go:97:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\log.go:97:24: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\log.go:100:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\log.go:100:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log.go:102:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\log.go:102:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log10.go:9:6: cannot inline Log10: no function body
..\..\..\..\math\log10.go:11:6: cannot inline log10: non-leaf function
..\..\..\..\math\log10.go:17:6: cannot inline Log2: no function body
..\..\..\..\math\log10.go:19:6: cannot inline log2: non-leaf function
..\..\..\..\math\log1p.go:97:6: cannot inline log1p: function too complex: cost 460 exceeds budget 80
..\..\..\..\math\log1p.go:117:22: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\log1p.go:118:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\log1p.go:118:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log1p.go:120:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\log1p.go:120:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log1p.go:121:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\log1p.go:122:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\log1p.go:122:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log1p.go:162:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\log1p.go:152:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\log1p.go:171:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\log1p.go:168:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:47:6: can inline ilogb as: func(float64) int { x, exp = normalize(x); return int(Float64bits(x) >> shift & mask) - bias + exp }
..\..\..\..\math\logb.go:48:21: inlining call to normalize func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\logb.go:48:21: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\logb.go:48:21: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\logb.go:48:21: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:49:25: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\logb.go:13:6: cannot inline Logb: function too complex: cost 158 exceeds budget 80
..\..\..\..\math\logb.go:17:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\logb.go:17:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:18:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\logb.go:19:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\logb.go:19:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:20:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\logb.go:23:22: inlining call to ilogb func(float64) int { x, exp = normalize(x); return int(Float64bits(x) >> shift & mask) - bias + exp }
..\..\..\..\math\logb.go:23:22: inlining call to normalize func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\logb.go:23:22: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\logb.go:23:22: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\logb.go:23:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:23:22: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\logb.go:32:6: cannot inline Ilogb: function too complex: cost 105 exceeds budget 80
..\..\..\..\math\logb.go:37:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\logb.go:39:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\logb.go:42:14: inlining call to ilogb func(float64) int { x, exp = normalize(x); return int(Float64bits(x) >> shift & mask) - bias + exp }
..\..\..\..\math\logb.go:42:14: inlining call to normalize func(float64) (float64, int) { <node DCLCONST>; if Abs(x) < SmallestNormal { return x * (1 << 52), -52 }; return x, 0 }
..\..\..\..\math\logb.go:42:14: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\logb.go:42:14: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\logb.go:42:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\logb.go:42:14: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\mod.go:23:6: cannot inline mod: non-leaf function
..\..\..\..\math\mod.go:24:20: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\mod.go:24:35: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\mod.go:24:47: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\mod.go:25:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\mod.go:25:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\modf.go:15:6: cannot inline modf: non-leaf function
..\..\..\..\math\modf.go:27:18: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\modf.go:34:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\unsafe.go:14:6: can inline Float32frombits as: func(uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
..\..\..\..\math\unsafe.go:10:6: can inline Float32bits as: func(float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:13:6: cannot inline Nextafter32: function too complex: cost 146 exceeds budget 80
..\..\..\..\math\nextafter.go:15:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\nextafter.go:15:33: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\nextafter.go:16:18: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\nextafter.go:16:18: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:20:47: inlining call to Float32frombits func(uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:20:23: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\nextafter.go:20:23: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:20:23: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:20:23: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:22:34: inlining call to Float32bits func(float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:22:22: inlining call to Float32frombits func(uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:24:34: inlining call to Float32bits func(float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:24:22: inlining call to Float32frombits func(uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:35:6: cannot inline Nextafter: function too complex: cost 140 exceeds budget 80
..\..\..\..\math\nextafter.go:37:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\nextafter.go:37:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\nextafter.go:38:10: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\nextafter.go:38:10: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:42:31: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:42:15: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\nextafter.go:42:15: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:42:15: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:42:15: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:44:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:44:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\nextafter.go:46:34: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\nextafter.go:46:22: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:7:6: cannot inline isOddInt: non-leaf function
..\..\..\..\math\pow.go:40:6: cannot inline pow: non-leaf function
..\..\..\..\math\pow.go:50:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\pow.go:50:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\pow.go:51:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\pow.go:51:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:56:24: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow.go:56:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:56:20: inlining call to Copysign func(float64, float64) float64 { <node DCLCONST>; return Float64frombits(Float64bits(x) &^ sign | Float64bits(y) & sign) }
..\..\..\..\math\pow.go:56:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\pow.go:56:20: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\pow.go:56:20: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:58:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow.go:58:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:65:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\pow.go:69:12: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\pow.go:69:12: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\pow.go:69:12: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:69:29: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\pow.go:72:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow.go:72:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:74:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\pow.go:75:11: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\pow.go:82:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow.go:82:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:94:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\pow.go:94:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:102:12: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\pow.go:102:12: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\pow.go:102:12: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow.go:105:14: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow.go:105:14: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\pow10.go:30:6: can inline Pow10 as: func(int) float64 { if 0 <= n && n <= 308 { return pow10postab32[uint(n) / 32] * pow10tab[uint(n) % 32] }; if -323 <= n && n <= 0 { return pow10negtab32[uint(-n) / 32] / pow10tab[uint(-n) % 32] }; if n > 0 { return Inf(1) }; return 0 }
..\..\..\..\math\pow10.go:41:13: inlining call to Inf func(int) float64 { var v uint64; v = <N>; if sign >= 0 { v = uvinf } else { v = uvneginf }; return Float64frombits(v) }
..\..\..\..\math\pow10.go:41:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\remainder.go:37:6: cannot inline Remainder: no function body
..\..\..\..\math\remainder.go:39:6: cannot inline remainder: non-leaf function
..\..\..\..\math\remainder.go:46:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\remainder.go:46:24: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\remainder.go:46:36: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\remainder.go:47:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\remainder.go:47:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\remainder.go:48:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\sin.go:119:6: cannot inline cos: function too complex: cost 230 exceeds budget 80
..\..\..\..\math\sin.go:128:12: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\sin.go:128:24: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\sin.go:129:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\sin.go:129:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sin.go:176:6: cannot inline sin: function too complex: cost 231 exceeds budget 80
..\..\..\..\math\sin.go:185:22: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\sin.go:187:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\sin.go:188:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\sin.go:188:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sinh.go:25:6: cannot inline Sinh: no function body
..\..\..\..\math\sinh.go:27:6: cannot inline sinh: non-leaf function
..\..\..\..\math\sinh.go:71:6: cannot inline Cosh: no function body
..\..\..\..\math\sinh.go:73:6: cannot inline cosh: non-leaf function
..\..\..\..\math\sqrt.go:99:6: cannot inline sqrt: unhandled op FOR
..\..\..\..\math\sqrt.go:102:22: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\sqrt.go:102:34: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\sqrt.go:105:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\sqrt.go:105:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\sqrt.go:107:19: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\sqrt.go:143:24: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\tan.go:82:6: cannot inline Tan: no function body
..\..\..\..\math\tan.go:84:6: cannot inline tan: function too complex: cost 188 exceeds budget 80
..\..\..\..\math\tan.go:93:22: inlining call to IsNaN func(float64) bool { return f != f }
..\..\..\..\math\tan.go:95:12: inlining call to IsInf func(float64, int) bool { return sign >= 0 && f > MaxFloat64 || sign <= 0 && f < -MaxFloat64 }
..\..\..\..\math\tan.go:96:13: inlining call to NaN func() float64 { return Float64frombits(uvnan) }
..\..\..\..\math\tan.go:96:13: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\tanh.go:74:6: cannot inline Tanh: no function body
..\..\..\..\math\tanh.go:76:6: cannot inline tanh: non-leaf function
..\..\..\..\math\tanh.go:78:10: inlining call to Abs func(float64) float64 { return Float64frombits(Float64bits(x) &^ (1 << 63)) }
..\..\..\..\math\tanh.go:78:10: inlining call to Float64bits func(float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
..\..\..\..\math\tanh.go:78:10: inlining call to Float64frombits func(uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
..\..\..\..\math\abs.go:13:36: Abs &f does not escape
..\..\..\..\math\abs.go:13:24: Abs &b does not escape
..\..\..\..\math\acosh.go:52:13: acosh &b does not escape
..\..\..\..\math\asin.go:31:13: asin &b does not escape
..\..\..\..\math\atan2.go:35:13: atan2 &b does not escape
..\..\..\..\math\atan2.go:37:24: atan2 &f does not escape
..\..\..\..\math\atan2.go:38:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:38:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:38:19: atan2 &b does not escape
..\..\..\..\math\atan2.go:40:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:40:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:40:18: atan2 &b does not escape
..\..\..\..\math\atan2.go:42:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:42:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:42:18: atan2 &b does not escape
..\..\..\..\math\atan2.go:47:20: atan2 &f does not escape
..\..\..\..\math\atan2.go:47:20: atan2 &f does not escape
..\..\..\..\math\atan2.go:47:20: atan2 &b does not escape
..\..\..\..\math\atan2.go:49:20: atan2 &f does not escape
..\..\..\..\math\atan2.go:49:20: atan2 &f does not escape
..\..\..\..\math\atan2.go:49:20: atan2 &b does not escape
..\..\..\..\math\atan2.go:54:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:54:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:54:19: atan2 &b does not escape
..\..\..\..\math\atan2.go:56:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:56:19: atan2 &f does not escape
..\..\..\..\math\atan2.go:56:19: atan2 &b does not escape
..\..\..\..\math\atan2.go:59:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:59:18: atan2 &f does not escape
..\..\..\..\math\atan2.go:59:18: atan2 &b does not escape
..\..\..\..\math\atanh.go:54:13: atanh &b does not escape
..\..\..\..\math\atanh.go:56:13: atanh &b does not escape
..\..\..\..\math\atanh.go:58:13: atanh &b does not escape
..\..\..\..\math\bits.go:27:24: Inf &b does not escape
..\..\..\..\math\bits.go:31:44: NaN &b does not escape
..\..\..\..\math\bits.go:58:8: normalize &f does not escape
..\..\..\..\math\bits.go:58:8: normalize &b does not escape
..\..\..\..\math\cbrt.go:51:34: cbrt &f does not escape
..\..\..\..\math\cbrt.go:51:22: cbrt &b does not escape
..\..\..\..\math\cbrt.go:56:34: cbrt &f does not escape
..\..\..\..\math\cbrt.go:56:22: cbrt &b does not escape
..\..\..\..\math\cbrt.go:65:33: cbrt &f does not escape
..\..\..\..\math\cbrt.go:65:21: cbrt &b does not escape
..\..\..\..\math\copysign.go:11:36: Copysign &f does not escape
..\..\..\..\math\copysign.go:11:59: Copysign &f does not escape
..\..\..\..\math\copysign.go:11:24: Copysign &b does not escape
..\..\..\..\math\dim.go:41:13: max &b does not escape
..\..\..\..\math\dim.go:43:13: max &b does not escape
..\..\..\..\math\dim.go:45:13: max &f does not escape
..\..\..\..\math\dim.go:68:13: min &b does not escape
..\..\..\..\math\dim.go:70:13: min &b does not escape
..\..\..\..\math\dim.go:72:13: min &f does not escape
..\..\..\..\math\erf.go:198:13: erf &b does not escape
..\..\..\..\math\erf.go:253:34: erf &f does not escape
..\..\..\..\math\erf.go:253:22: erf &b does not escape
..\..\..\..\math\erf.go:274:13: erfc &b does not escape
..\..\..\..\math\erf.go:328:35: erfc &f does not escape
..\..\..\..\math\erf.go:328:23: erfc &b does not escape
..\..\..\..\math\erfinv.go:80:14: Erfinv &b does not escape
..\..\..\..\math\erfinv.go:82:13: Erfinv &b does not escape
..\..\..\..\math\exp.go:110:13: exp &b does not escape
..\..\..\..\math\exp.go:153:13: exp2 &b does not escape
..\..\..\..\math\expm1.go:165:14: expm1 &b does not escape
..\..\..\..\math\expm1.go:223:34: expm1 &f does not escape
..\..\..\..\math\expm1.go:223:22: expm1 &b does not escape
..\..\..\..\math\expm1.go:227:23: expm1 &b does not escape
..\..\..\..\math\expm1.go:229:34: expm1 &f does not escape
..\..\..\..\math\expm1.go:229:22: expm1 &b does not escape
..\..\..\..\math\expm1.go:232:21: expm1 &b does not escape
..\..\..\..\math\expm1.go:235:33: expm1 &f does not escape
..\..\..\..\math\expm1.go:235:21: expm1 &b does not escape
..\..\..\..\math\floor.go:74:21: Round &f does not escape
..\..\..\..\math\floor.go:92:24: Round &b does not escape
..\..\..\..\math\floor.go:112:21: RoundToEven &f does not escape
..\..\..\..\math\floor.go:130:24: RoundToEven &b does not escape
..\..\..\..\math\frexp.go:26:20: frexp &f does not escape
..\..\..\..\math\frexp.go:26:20: frexp &b does not escape
..\..\..\..\math\frexp.go:27:18: frexp &f does not escape
..\..\..\..\math\frexp.go:31:24: frexp &b does not escape
..\..\..\..\math\gamma.go:102:13: stirling &b does not escape
..\..\..\..\math\gamma.go:135:13: Gamma &b does not escape
..\..\..\..\math\gamma.go:137:13: Gamma &b does not escape
..\..\..\..\math\gamma.go:139:13: Gamma &f does not escape
..\..\..\..\math\gamma.go:140:14: Gamma &b does not escape
..\..\..\..\math\gamma.go:142:13: Gamma &b does not escape
..\..\..\..\math\gamma.go:144:10: Gamma &f does not escape
..\..\..\..\math\gamma.go:144:10: Gamma &b does not escape
..\..\..\..\math\gamma.go:165:14: Gamma &b does not escape
..\..\..\..\math\gamma.go:168:14: Gamma &f does not escape
..\..\..\..\math\gamma.go:168:14: Gamma &b does not escape
..\..\..\..\math\gamma.go:210:13: Gamma &b does not escape
..\..\..\..\math\hypot.go:25:13: hypot &b does not escape
..\..\..\..\math\hypot.go:27:13: hypot &b does not escape
..\..\..\..\math\sincos.go:29:13: Sincos &b does not escape
..\..\..\..\math\sincos.go:29:20: Sincos &b does not escape
..\..\..\..\math\j0.go:311:7: pzero &p0R8 does not escape
..\..\..\..\math\j0.go:312:7: pzero &p0S8 does not escape
..\..\..\..\math\j0.go:314:7: pzero &p0R5 does not escape
..\..\..\..\math\j0.go:315:7: pzero &p0S5 does not escape
..\..\..\..\math\j0.go:317:7: pzero &p0R3 does not escape
..\..\..\..\math\j0.go:318:7: pzero &p0S3 does not escape
..\..\..\..\math\j0.go:320:7: pzero &p0R2 does not escape
..\..\..\..\math\j0.go:321:7: pzero &p0S2 does not escape
..\..\..\..\math\j0.go:413:7: qzero &q0R8 does not escape
..\..\..\..\math\j0.go:414:7: qzero &q0S8 does not escape
..\..\..\..\math\j0.go:416:7: qzero &q0R5 does not escape
..\..\..\..\math\j0.go:417:7: qzero &q0S5 does not escape
..\..\..\..\math\j0.go:419:7: qzero &q0R3 does not escape
..\..\..\..\math\j0.go:420:7: qzero &q0S3 does not escape
..\..\..\..\math\j0.go:422:7: qzero &q0R2 does not escape
..\..\..\..\math\j0.go:423:7: qzero &q0S2 does not escape
..\..\..\..\math\j0.go:175:13: Y0 &b does not escape
..\..\..\..\math\j0.go:179:13: Y0 &b does not escape
..\..\..\..\math\j1.go:304:7: pone &p1R8 does not escape
..\..\..\..\math\j1.go:305:7: pone &p1S8 does not escape
..\..\..\..\math\j1.go:307:7: pone &p1R5 does not escape
..\..\..\..\math\j1.go:308:7: pone &p1S5 does not escape
..\..\..\..\math\j1.go:310:7: pone &p1R3 does not escape
..\..\..\..\math\j1.go:311:7: pone &p1S3 does not escape
..\..\..\..\math\j1.go:313:7: pone &p1R2 does not escape
..\..\..\..\math\j1.go:314:7: pone &p1S2 does not escape
..\..\..\..\math\j1.go:406:7: qone &q1R8 does not escape
..\..\..\..\math\j1.go:407:7: qone &q1S8 does not escape
..\..\..\..\math\j1.go:409:7: qone &q1R5 does not escape
..\..\..\..\math\j1.go:410:7: qone &q1S5 does not escape
..\..\..\..\math\j1.go:412:7: qone &q1R3 does not escape
..\..\..\..\math\j1.go:413:7: qone &q1S3 does not escape
..\..\..\..\math\j1.go:415:7: qone &q1R2 does not escape
..\..\..\..\math\j1.go:416:7: qone &q1S2 does not escape
..\..\..\..\math\j1.go:172:13: Y1 &b does not escape
..\..\..\..\math\j1.go:176:13: Y1 &b does not escape
..\..\..\..\math\jn.go:198:23: Jn &f does not escape
..\..\..\..\math\jn.go:198:23: Jn &b does not escape
..\..\..\..\math\jn.go:238:13: Yn &b does not escape
..\..\..\..\math\jn.go:248:14: Yn &b does not escape
..\..\..\..\math\jn.go:250:13: Yn &b does not escape
..\..\..\..\math\ldexp.go:24:22: ldexp &f does not escape
..\..\..\..\math\ldexp.go:24:22: ldexp &b does not escape
..\..\..\..\math\ldexp.go:26:18: ldexp &f does not escape
..\..\..\..\math\ldexp.go:29:18: ldexp &f does not escape
..\..\..\..\math\ldexp.go:29:18: ldexp &f does not escape
..\..\..\..\math\ldexp.go:29:18: ldexp &b does not escape
..\..\..\..\math\ldexp.go:33:14: ldexp &b does not escape
..\..\..\..\math\ldexp.go:35:13: ldexp &b does not escape
..\..\..\..\math\ldexp.go:44:28: ldexp &b does not escape
..\..\..\..\math\lgamma.go:347:27: sinPi &f does not escape
..\..\..\..\math\lgamma.go:196:15: Lgamma &b does not escape
..\..\..\..\math\lgamma.go:216:16: Lgamma &b does not escape
..\..\..\..\math\lgamma.go:221:16: Lgamma &b does not escape
..\..\..\..\math\lgamma.go:224:22: Lgamma &f does not escape
..\..\..\..\math\lgamma.go:224:22: Lgamma &b does not escape
..\..\..\..\math\log.go:100:13: log &b does not escape
..\..\..\..\math\log.go:102:13: log &b does not escape
..\..\..\..\math\log1p.go:118:13: log1p &b does not escape
..\..\..\..\math\log1p.go:120:13: log1p &b does not escape
..\..\..\..\math\log1p.go:122:13: log1p &b does not escape
..\..\..\..\math\log1p.go:152:20: log1p &f does not escape
..\..\..\..\math\log1p.go:162:20: log1p &f does not escape
..\..\..\..\math\log1p.go:168:23: log1p &b does not escape
..\..\..\..\math\log1p.go:171:23: log1p &b does not escape
..\..\..\..\math\logb.go:17:13: Logb &b does not escape
..\..\..\..\math\logb.go:19:13: Logb &b does not escape
..\..\..\..\math\logb.go:23:22: Logb &f does not escape
..\..\..\..\math\logb.go:23:22: Logb &b does not escape
..\..\..\..\math\logb.go:23:22: Logb &f does not escape
..\..\..\..\math\logb.go:42:14: Ilogb &f does not escape
..\..\..\..\math\logb.go:42:14: Ilogb &b does not escape
..\..\..\..\math\logb.go:42:14: Ilogb &f does not escape
..\..\..\..\math\logb.go:48:21: ilogb &f does not escape
..\..\..\..\math\logb.go:48:21: ilogb &b does not escape
..\..\..\..\math\logb.go:49:25: ilogb &f does not escape
..\..\..\..\math\mod.go:25:13: mod &b does not escape
..\..\..\..\math\modf.go:27:18: modf &f does not escape
..\..\..\..\math\modf.go:34:23: modf &b does not escape
..\..\..\..\math\nextafter.go:16:18: Nextafter32 &b does not escape
..\..\..\..\math\nextafter.go:20:47: Nextafter32 &b does not escape
..\..\..\..\math\nextafter.go:20:23: Nextafter32 &f does not escape
..\..\..\..\math\nextafter.go:20:23: Nextafter32 &f does not escape
..\..\..\..\math\nextafter.go:20:23: Nextafter32 &b does not escape
..\..\..\..\math\nextafter.go:22:34: Nextafter32 &f does not escape
..\..\..\..\math\nextafter.go:22:22: Nextafter32 &b does not escape
..\..\..\..\math\nextafter.go:24:34: Nextafter32 &f does not escape
..\..\..\..\math\nextafter.go:24:22: Nextafter32 &b does not escape
..\..\..\..\math\nextafter.go:38:10: Nextafter &b does not escape
..\..\..\..\math\nextafter.go:42:31: Nextafter &b does not escape
..\..\..\..\math\nextafter.go:42:15: Nextafter &f does not escape
..\..\..\..\math\nextafter.go:42:15: Nextafter &f does not escape
..\..\..\..\math\nextafter.go:42:15: Nextafter &b does not escape
..\..\..\..\math\nextafter.go:44:34: Nextafter &f does not escape
..\..\..\..\math\nextafter.go:44:22: Nextafter &b does not escape
..\..\..\..\math\nextafter.go:46:34: Nextafter &f does not escape
..\..\..\..\math\nextafter.go:46:22: Nextafter &b does not escape
..\..\..\..\math\pow.go:51:13: pow &b does not escape
..\..\..\..\math\pow.go:56:24: pow &b does not escape
..\..\..\..\math\pow.go:56:20: pow &f does not escape
..\..\..\..\math\pow.go:56:20: pow &f does not escape
..\..\..\..\math\pow.go:56:20: pow &b does not escape
..\..\..\..\math\pow.go:58:14: pow &b does not escape
..\..\..\..\math\pow.go:69:12: pow &f does not escape
..\..\..\..\math\pow.go:69:12: pow &b does not escape
..\..\..\..\math\pow.go:72:14: pow &b does not escape
..\..\..\..\math\pow.go:82:14: pow &b does not escape
..\..\..\..\math\pow.go:94:13: pow &b does not escape
..\..\..\..\math\pow.go:102:12: pow &f does not escape
..\..\..\..\math\pow.go:102:12: pow &b does not escape
..\..\..\..\math\pow.go:105:14: pow &b does not escape
..\..\..\..\math\pow10.go:41:13: Pow10 &b does not escape
..\..\..\..\math\remainder.go:47:13: remainder &b does not escape
..\..\..\..\math\signbit.go:9:20: Signbit &f does not escape
..\..\..\..\math\sin.go:129:13: cos &b does not escape
..\..\..\..\math\sin.go:188:13: sin &b does not escape
..\..\..\..\math\sqrt.go:105:13: sqrt &b does not escape
..\..\..\..\math\sqrt.go:107:19: sqrt &f does not escape
..\..\..\..\math\sqrt.go:143:24: sqrt &b does not escape
..\..\..\..\math\tan.go:96:13: tan &b does not escape
..\..\..\..\math\tanh.go:78:10: tanh &f does not escape
..\..\..\..\math\tanh.go:78:10: tanh &b does not escape
..\..\..\..\math\unsafe.go:10:71: Float32bits &f does not escape
..\..\..\..\math\unsafe.go:14:76: Float32frombits &b does not escape
..\..\..\..\math\unsafe.go:17:71: Float64bits &f does not escape
..\..\..\..\math\unsafe.go:21:76: Float64frombits &b does not escape
..\..\..\..\math\pow10.go:32:46: index bounds check elided
..\..\..\..\math\pow10.go:36:47: index bounds check elided
